구조체 임베딩(합성)은 어떻게 동작하나요?

Question

Accepted Answer

Go에는 **상속이 없습니다** — 대신 구조체 임베딩을 통한 **합성(composition)**을 사용합니다. 한 구조체(또는 interface)를 다른 구조체 안에 임베딩하면, 외부 타입이 내부 타입의 필드와 메서드를 직접 얻습니다. 이것이 코드 재사용에 대한 Go의 답으로, "is-a" 상속보다 "has-a" 합성을 선호합니다.

## 구조체 임베딩

```go
type Animal struct {
    Name string
}
func (a Animal) Eat() string {
    return a.Name + " is eating"
}

type Dog struct {
    Animal    // 임베딩 — 필드 이름 없이 타입만 → 합성
    Breed string
}

d := Dog{
    Animal: Animal{Name: "Rex"},
    Breed:  "Lab",
}

// Dog는 Animal의 필드와 메서드가 승격(promote)됨 — 직접 접근
fmt.Println(d.Name)     // "Rex" — 임베딩된 Animal에서 승격
fmt.Println(d.Eat())    // "Rex is eating" — Dog에서 호출된 Animal의 메서드
```

임베딩(필드 이름 없이 타입 이름만 쓰기)은 임베딩된 타입의 필드와 메서드를 외부 구조체로 **승격**합니다 — 그래서 `d.Name`과 `d.Eat()`이 `Dog`에 속한 것처럼 동작합니다. 상속처럼 보이지만 합성입니다: `Dog`는 `Animal`을 *가집니다*.

## 승격된 메서드 오버라이드

```go
func (d Dog) Eat() string {        // Dog가 자신의 Eat()를 정의
    return d.Name + " the dog eats noisily"
}
d.Eat()         // Dog의 Eat 호출(외부가 임베딩된 것을 가림)
d.Animal.Eat()  // 필요하면 임베딩된 Animal의 Eat를 명시적으로 호출
```

외부 타입은 같은 이름의 메서드를 정의해 승격된 것을 "오버라이드"(가림)할 수 있습니다; 임베딩된 버전은 여전히 명시적으로 도달할 수 있습니다.

## interface 임베딩(매우 흔함)

```go
// interface를 임베딩하여 더 큰 것을 합성
type Reader interface { Read(p []byte) (int, error) }
type Writer interface { Write(p []byte) (int, error) }

type ReadWriter interface {   // 임베딩으로 둘에서 합성
    Reader
    Writer
}
// (이것이 표준 라이브러리에서 io.ReadWriter가 정의된 정확한 방식)
```

interface 임베딩은 작은 interface를 더 큰 것으로 합성합니다 — 표준 라이브러리 전반에 사용됩니다.

## 상속보다 합성 — Go 철학

```text
클래스 계층 없음, "extends" 없음. 대신:
  ✓ 임베딩으로 필드/메서드 재사용(has-a)
  ✓ interface 임베딩으로 동작 계약 합성
  ✓ 상속의 취약성, 깊은 계층, 강한 결합을 피함
```

## 왜 중요한가

구조체 임베딩은 **코드 재사용과 합성**을 위한 Go의 독특한 메커니즘으로, 대부분의 OOP 언어에 있는 상속을 대체합니다.

이를 이해하는 것은 필수적인데, 이것이 Go가 재사용을 달성하는 방법(임베딩된 필드/메서드를 승격하여 외부 타입이 합성을 통해 동작을 "상속")이면서 상속의 잘 알려진 문제(취약한 베이스 클래스, 깊고 경직된 계층, 강한 결합)를 의도적으로 피하기 때문입니다.

널리 지지되는 원칙 **"상속보다 합성"**을 구현합니다. 임베딩은 끊임없이 나타납니다 — 재사용을 위한 구조체 임베딩, 더 큰 계약을 만드는 interface 임베딩(`io.ReadWriter`처럼), 믹스인 스타일 동작을 위한 임베딩.

Go에 상속이 없고 임베딩이 그 합성적 대안이라는 점 — 그리고 메서드 승격과 가림 규칙 — 을 인식하는 것은 관용적 Go를 읽고 설계하는 데 기본이며, 클래스 기반 언어와 다르기에 흔한 면접 주제입니다.