第 13/41 课 · 复合数据类型与面向对象基础 m02-l04

组合优于继承：嵌入、接口组合与设计套路

🎬 配套视频讲解（B 站）

本课所属：第二模块：复合数据类型与面向对象｜课时：m02-l04 ｜难度：入门学完本课你将能够：掌握通过嵌入实现代码复用、利用接口组合构建最小接口，并熟练运用 io.Reader/Writer 范式进行面向接口编程。

一、学习目标

理解 Go 语言中组合优于继承的设计哲学，掌握嵌入语法实现代码复用。
掌握接口组合与最小接口原则，能够定义清晰且易于实现的接口。
熟悉 io.Reader 与 io.Writer 生态，能够利用组合模式构建可复用的 I/O 组件。
能够识别并避免常见的嵌入陷阱，如方法遮蔽与接收者类型混淆。

二、知识讲解

2.1 嵌入：代码复用的基石

Go 语言没有 extends 关键字，也不支持传统面向对象中的类继承。取而代之的是嵌入（Embedding）。嵌入允许在一个结构体中直接包含另一个结构体或接口类型，从而复用其字段和方法。

是什么：当结构体 A 嵌入结构体 B 时，A 会自动获得 B 的所有公开字段和方法。这被称为方法提升（Method Promotion）。注意，嵌入不仅限于结构体，也可以嵌入接口。

为什么这样设计：嵌入实现了组合（Composition）。与继承不同，组合不强制建立“is-a”的强耦合关系，而是建立“has-a”的关系。这使得代码更灵活、更易于测试和复用。

怎么用：

type Base struct {
    Name string
}

func (b Base) SayHello() {
    fmt.Println("Hello, I am", b.Name)
}

type Derived struct {
    Base // 嵌入 Base
    Age  int
}

在此例中，Derived 实例可以直接调用 SayHello()，因为 Base 的方法被提升到了 Derived。

2.2 接口组合与最小接口原则

接口组合是通过在接口中嵌入其他接口类型来合并方法集。Go 中没有 + 号语法，而是直接列出嵌入的接口名。

最小接口（Smallest Interface）原则指出：接口应该尽可能小，只包含调用者真正需要的方法。越小的接口越容易实现，也越容易组合。

怎么用：

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

// 接口组合：ReadWriter 嵌入了 Reader 和 Writer
type ReadWriter interface {
    Reader
    Writer
}

ReadWriter 的方法集是 Reader 和 Writer 方法集的并集。

2.3 io.Reader/Writer 组合范式

io.Reader 和 io.Writer 是 Go 标准库中最核心的接口。它们定义了数据流的输入和输出。通过嵌入这些接口，我们可以构建功能丰富的组件。

怎么用：例如，io.Pipe 返回一个 PipeReader 和一个 PipeWriter，它们都实现了 io.Reader 或 io.Writer。我们可以将任何 io.Reader 包装成带有日志功能的 Reader，只需嵌入原 Reader 并重写 Read 方法即可。

三、示例代码

示例 1：结构体嵌入与方法提升

本示例演示如何通过嵌入实现代码复用，以及方法提升的机制。

package main

import (
    "fmt"
)

// Base 定义基础行为
type Base struct {
    Name string
}

// SayHello 是 Base 的方法
func (b Base) SayHello() {
    fmt.Println("Hello, I am", b.Name)
}

// Derived 嵌入 Base，复用其字段和方法
type Derived struct {
    Base
    Age int
}

// OverrideSayHello 是 Derived 自己的方法，与提升上来的 SayHello 并存
func (d Derived) OverrideSayHello() {
    fmt.Println("Derived says Hello, I am", d.Name)
}

func main() {
    d := Derived{
        Base: Base{Name: "Alice"},
        Age:  18,
    }

    // 调用提升上来的方法
    d.SayHello()
    // 调用 Derived 自己的方法
    d.OverrideSayHello()
}

运行结果（预期输出）：

Hello, I am Alice
Derived says Hello, I am Alice

示例 2：接口组合与 io.Reader 包装器

本示例演示接口组合以及如何使用嵌入构建一个带缓冲的 io.Reader，体现面向接口编程的优势。

package main

import (
    "fmt"
    "io"
    "strings"
)

// BufferedReader 嵌入 io.Reader，实现带缓冲的读取逻辑
type BufferedReader struct {
    io.Reader
    buffer []byte
    pos    int
}

// NewBufferedReader 创建一个新的 BufferedReader
func NewBufferedReader(r io.Reader) *BufferedReader {
    return &BufferedReader{
        Reader: r,
        buffer: make([]byte, 1024),
    }
}

// Read 重写 Read 方法，演示如何委托给嵌入的 Reader
func (br *BufferedReader) Read(p []byte) (n int, err error) {
    // 这里简化逻辑：直接委托给底层 Reader
    // 实际缓冲读取会更复杂，需处理 buffer 剩余数据
    n, err = br.Reader.Read(p)
    if err != nil && err != io.EOF {
        return n, err
    }
    return n, err
}

func main() {
    // 创建一个字符串读取器
    strReader := strings.NewReader("Hello, Go!")

    // 包装成 BufferedReader
    br := NewBufferedReader(strReader)

    // 读取数据
    buf := make([]byte, 10)
    n, err := br.Read(buf)
    if err != nil && err != io.EOF {
        fmt.Println("Error:", err)
        return
    }

    fmt.Printf("Read %d bytes: %s\n", n, string(buf[:n]))
}

运行结果（预期输出）：

Read 10 bytes: Hello, Go!

四、常见错误与避坑指南

错误认知：使用 + 号组合接口
错误写法：type ReadWriter interface { Reader + Writer }
原因：Go 语言不支持使用 + 号合并接口。
正确做法：直接嵌入接口类型。 go type ReadWriter interface { Reader Writer }
错误认知：认为嵌入接口必须实现方法
错误写法：认为在结构体中嵌入 io.Reader 后，必须手动实现 Read 方法才能满足 io.Reader 接口。
原因：嵌入接口时，接口的方法会被提升为结构体的方法。结构体无需自己实现即可满足接口（只要嵌入字段非 nil，调用才可用）。
正确做法：直接嵌入。若需委托，可在方法中调用嵌入字段的方法。 go type MyReader struct { io.Reader } // MyReader 自动满足 io.Reader 接口 var _ io.Reader = MyReader{}
错误认知：值接收者与指针接收者的混淆
错误写法： go type MyStruct struct{} func (m MyStruct) Read(p []byte) (int, error) { return 0, nil } var rw ReadWriter = &MyStruct{} // 假设 ReadWriter 需要指针接收者
原因：如果接口方法是指针接收者，只有 *MyStruct 实现该接口；如果是值接收者，MyStruct 和 *MyStruct 都实现。若 B 的方法是指针接收者，A 嵌入 B 后，只有 *A 实现该接口。
正确做法：根据接口定义选择合适的接收者类型。若接口方法为值接收者，值类型和指针类型均可实现；若为指针接收者，仅指针类型可实现。

五、最佳实践

优先使用组合而非继承：Go 没有继承，通过嵌入实现代码复用，保持结构的松耦合。
遵循最小接口原则：定义接口时，只包含调用者真正需要的方法，避免接口膨胀。
利用 io.Reader/io.Writer 进行装饰：通过嵌入这些接口，可以轻松构建日志、缓冲、压缩等装饰器模式。
注意方法遮蔽：如果外层结构体定义了与嵌入结构体同名的方法，外层方法会遮蔽内层方法，可能导致接口实现失败。
明确接收者类型：在嵌入接口时，注意值类型和指针类型对接口实现的影响，确保正确使用。

六、练习题

概念题：解释 Go 语言中“组合优于继承”的含义，并说明嵌入如何实现代码复用。
编码题：定义一个 LoggingReader 结构体，嵌入 io.Reader，并重写 Read 方法，在每次读取前打印日志 "Reading..."。
进阶/调试题：分析以下代码，指出其编译错误的原因，并修复代码，使其能正确输出 "Base Method" 和 "Derived Method"。 ```go package main

import "fmt"

type Base struct{}

func (b Base) Method() { fmt.Println("Base Method") }

type Derived struct { Base }

func (d Derived) Method() { fmt.Println("Derived Method") }

func main() { d := Derived{} // 请修改此处，使其能分别调用到 Derived 与 Base 两个 Method d.Method() } ```

七、练习参考答案

参考答案（点击展开 / 收起）

第 1 题

Go 语言中的“组合优于继承”意味着通过组合（Embedding）来复用代码，而不是通过继承（Inheritance）来扩展类。嵌入允许一个结构体包含另一个结构体，从而自动获得其字段和方法（方法提升）。这种方式更灵活，避免了继承带来的强耦合和类层次结构复杂化的问题。

第 2 题

package main

import (
    "fmt"
    "io"
    "strings"
)

type LoggingReader struct {
    io.Reader
}

func (lr *LoggingReader) Read(p []byte) (n int, err error) {
    fmt.Println("Reading...")
    return lr.Reader.Read(p)
}

func main() {
    str := strings.NewReader("Hello")
    lr := &LoggingReader{Reader: str}
    buf := make([]byte, 10)
    lr.Read(buf)
}

第 3 题

问题所在： 1. 题干要求输出 "Base Method" 和 "Derived Method"，但原代码只调用了一次 d.Method()，只会输出 "Derived Method"。 2. 若要调用 Base 的 Method，需要通过嵌入的字段 Base 来调用，即 d.Base.Method()。

修复后的代码：

package main

import "fmt"

type Base struct{}

func (b Base) Method() {
    fmt.Println("Base Method")
}

type Derived struct {
    Base
}

func (d Derived) Method() {
    fmt.Println("Derived Method")
}

func main() {
    d := Derived{}
    d.Method()       // 调用 Derived 的 Method
    d.Base.Method()  // 调用 Base 的 Method
}

八、本课小结

嵌入是 Go 语言实现代码复用的核心机制，通过方法提升实现代码共享。
接口组合通过嵌入其他接口来合并方法集，遵循最小接口原则。
io.Reader 和 io.Writer 是构建可复用 I/O 组件的基础，支持装饰器模式。
注意值/指针接收者对接口实现的影响，以及方法遮蔽问题。
下一课预告：深入探索 Go 的并发原语：goroutine 与 channel 的通信机制。