構造体の埋め込み（composition）はどのように機能するのか？

Question

Accepted Answer

Go は**継承がない** — 代わりに**構造体埋め込みを通じた composition** を使用します。あるストラクト（またはインターフェイス）を別のストラクトの内部に埋め込むことで、外側の型は内側の型のフィールドとメソッドを直接取得します。これは Go のコード再利用への答えであり、"is-a" 継承よりも "has-a" composition を優先します。

## 構造体の埋め込み

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

type Dog struct {
    Animal    // EMBEDDED — no field name, just the type → composition
    Breed string
}

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

// Dog gets Animal's fields and methods PROMOTED — accessed directly
fmt.Println(d.Name)     // "Rex" — promoted from the embedded Animal
fmt.Println(d.Eat())    // "Rex is eating" — Animal's method, called on Dog
```

埋め込み（フィールド名なしで型名のみを記述）は、埋め込まれた型のフィールドとメソッドを外側のストラクトに**昇格させます** — したがって、`d.Name` と `d.Eat()` は `Dog` に属しているかのように機能します。これは継承のように見えますが、composition です：`Dog` は `Animal` を*持っています*。

## 昇格したメソッドのオーバーライド

```go
func (d Dog) Eat() string {        // Dog defines its OWN Eat()
    return d.Name + " the dog eats noisily"
}
d.Eat()         // calls Dog's Eat (the outer one shadows the embedded one)
d.Animal.Eat()  // explicitly call the embedded Animal's Eat if needed
```

外側の型は同じ名前のメソッドを定義して、昇格したメソッドを "shadow" できます。埋め込まれたバージョンに明示的にアクセスすることはできます。

## インターフェイスの埋め込み（非常に一般的）

```go
// embed interfaces to compose larger ones
type Reader interface { Read(p []byte) (int, error) }
type Writer interface { Write(p []byte) (int, error) }

type ReadWriter interface {   // composed from both via embedding
    Reader
    Writer
}
// (this is exactly how io.ReadWriter is defined in the standard library)
```

インターフェイスの埋め込みは、小さなインターフェイスをより大きなインターフェイスに合成します — 標準ライブラリ全体で使用されています。

## Composition over inheritance — Go の哲学

```text
No class hierarchies, no "extends". Instead:
  ✓ Embed to reuse fields/methods (has-a)
  ✓ Embed interfaces to compose behavior contracts
  ✓ Avoids the fragility, deep hierarchies, and tight coupling of inheritance
```

## なぜ重要なのか

構造体の埋め込みは、**コード再利用と composition** のための Go 独有のメカニズムであり、ほとんどの OOP 言語にある継承を置き換えます。

これを理解することは、Go がどのように再利用を達成するか（埋め込まれたフィールド/メソッドを昇格させることで、外側の型が composition を通じてビヘイビアを "継承" できるようにする）を示しているため、不可欠です。同時に意図的に継承の周知の問題（脆弱な基底クラス、深い厳密な階層、密結合）を回避します。

これは広く推奨されている原則 **"composition over inheritance"** を具現化しています。埋め込みは常に現れます — 再利用のための構造体の埋め込み、より大きなコントラクト（`io.ReadWriter` のような）を構築するためのインターフェイスの埋め込み、および mixin スタイルの動作のための埋め込み。

Go には継承がなく、埋め込みがその合成的な代替手段であること、およびメソッド昇格と shadow ルールを認識することは、慣用的な Go を読んで設計するために基本的であり、クラスベースの言語とどのように異なるかを考えると、一般的なインタビュートピックです。