结构体嵌入（组合）是如何工作的？

Question

结构体嵌入（组合）是如何工作的？

Accepted Answer

Go **没有继承** —— 取而代之的是通过结构体嵌入实现的**组合**。通过将一个结构体（或接口）嵌入到另一个结构体中，外层类型可以直接获得内层类型的字段和方法。这是 Go 对代码复用的解答，它倾向于使用 "has-a"（拥有）的组合，而非 "is-a"（是一个）的继承。

## 嵌入一个结构体

```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
```

嵌入（只写类型名，不写字段名）会将被嵌入类型的字段和方法**提升（promote）**到外层结构体 —— 因此 `d.Name` 和 `d.Eat()` 就像它们本就属于 `Dog` 一样可以使用。这看起来像继承，但其实是组合：`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)
```

接口嵌入将小接口组合成更大的接口 —— 这种用法在整个标准库中随处可见。

## 组合优于继承 —— 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
```

## 为什么这很重要

结构体嵌入是 Go 实现**代码复用与组合**的独特机制，它取代了大多数面向对象语言中的继承。

理解它至关重要，因为这正是 Go 实现复用的方式（通过提升被嵌入的字段/方法，使外层类型借助组合"继承"了行为），同时又有意避开了继承众所周知的问题（脆弱的基类、深而僵化的层次结构、紧密耦合）。

它体现了被广泛认可的原则 **"组合优于继承"**。嵌入无处不在 —— 嵌入结构体以实现复用、嵌入接口以构建更大的契约（如 `io.ReadWriter`）、以及为了实现 mixin 风格的行为而嵌入。

认识到 Go 没有继承、嵌入是其组合式的替代方案 —— 再加上方法提升与遮蔽的规则 —— 对于阅读和设计地道的 Go 代码是基础性的，而且鉴于它与基于类的语言差异明显，也是一个常见的面试话题。