PHP小码农

Appearance

方法集 ​

1. 概述 ​

方法集是 Go 语言中的一个重要概念，它指的是一个类型所有可调用的方法的集合。方法集的规则决定了一个类型是否实现了某个接口，以及在不同情况下哪些方法可以被调用。理解方法集对于掌握 Go 语言的接口实现和类型系统至关重要。本知识点承接类型嵌入的概念，是 Go 语言面向对象编程的总结性内容。

2. 基本概念 ​

2.1 语法 ​

方法集的定义 ​

go
// 值类型的方法集
// 包含所有值接收者方法

// 指针类型的方法集
// 包含所有值接收者方法和指针接收者方法

// 示例：方法集
package main

import "fmt"

type T struct {
    Value int
}

// 值接收者方法
func (t T) ValueMethod() {
    fmt.Println("ValueMethod called")
}

// 指针接收者方法
func (t *T) PointerMethod() {
    fmt.Println("PointerMethod called")
}

func main() {
    t := T{Value: 42}
    pt := &T{Value: 42}
    
    // 值类型可以调用值接收者方法
    t.ValueMethod()
    
    // 值类型可以调用指针接收者方法（编译器自动取地址）
    t.PointerMethod()
    
    // 指针类型可以调用值接收者方法（编译器自动解引用）
    pt.ValueMethod()
    
    // 指针类型可以调用指针接收者方法
    pt.PointerMethod()
}

方法集的规则 ​

go
// 方法集规则
// 1. 值类型 T 的方法集包含所有接收者为 T 的方法
// 2. 指针类型 *T 的方法集包含所有接收者为 T 和 *T 的方法
// 3. 当类型 T 实现了接口 I 时，*T 也实现了接口 I
// 4. 当类型 *T 实现了接口 I 时，T 不一定实现了接口 I

// 示例：接口实现与方法集
package main

import "fmt"

type I interface {
    Method()
}

type T struct {
    Value int
}

// 值接收者实现接口
func (t T) Method() {
    fmt.Println("Method called")
}

func main() {
    var i I
    
    // 值类型实现了接口
    t := T{Value: 42}
    i = t
    i.Method()
    
    // 指针类型也实现了接口
    pt := &T{Value: 42}
    i = pt
    i.Method()
}

2.2 语义 ​

  • 方法集：一个类型所有可调用的方法的集合
  • 值类型方法集：包含所有值接收者方法
  • 指针类型方法集：包含所有值接收者方法和指针接收者方法
  • 接口实现：当一个类型的方法集包含接口的所有方法时，该类型实现了接口
  • 自动转换：Go 语言会在值和指针之间自动转换，使方法调用更加灵活

2.3 规范 ​

  • 一致性：对于同一个类型，方法集应该保持一致的风格
  • 性能考虑：对于大型结构体，使用指针接收者可以避免值拷贝
  • 接口实现：根据接口的使用场景选择合适的接收者类型
  • 代码可读性：方法的接收者类型应该清晰表达其意图

3. 原理深度解析 ​

3.1 方法集的底层实现 ​

方法集在 Go 语言的编译时确定，编译器会为每个类型维护一个方法集表。当调用方法时，编译器会检查该类型的方法集是否包含被调用的方法。

3.2 方法调用的机制 ​

当调用一个方法时，Go 语言的编译器会：

  1. 检查调用者的类型
  2. 查找该类型的方法集
  3. 如果找到匹配的方法，生成调用代码
  4. 如果没有找到，编译错误

3.3 接口实现的判断 ​

当判断一个类型是否实现了某个接口时，Go 语言的编译器会：

  1. 获取该类型的方法集
  2. 检查接口的所有方法是否都在该类型的方法集中
  3. 如果都在，该类型实现了接口；否则，没有实现

3.4 方法集与类型转换 ​

  • 当将值类型转换为指针类型时，方法集从值接收者方法扩展为值接收者方法和指针接收者方法
  • 当将指针类型转换为值类型时，方法集从值接收者方法和指针接收者方法缩小为值接收者方法

4. 常见错误与踩坑点 ​

4.1 错误表现：值类型无法实现包含指针接收者方法的接口 ​

产生原因：值类型的方法集不包含指针接收者方法 解决方案：使用指针类型实现接口，或为值类型添加相应的方法

4.2 错误表现：方法调用时的接收者类型错误 ​

产生原因：没有理解方法集的规则，尝试调用不存在于方法集中的方法 解决方案：了解值类型和指针类型的方法集差异，根据需要使用正确的类型

4.3 错误表现：接口实现判断错误 ​

产生原因：错误地认为值类型和指针类型的接口实现是等价的 解决方案：记住只有当值类型的方法集包含接口的所有方法时，值类型才实现了接口

4.4 错误表现：方法接收者类型不一致 ​

产生原因：为同一个类型的方法使用了混合的接收者类型，导致方法集混乱 解决方案：保持接收者类型的一致性，要么全部使用值接收者，要么全部使用指针接收者

5. 常见应用场景 ​

5.1 场景描述：接口实现判断 ​

使用方法：根据方法集规则判断一个类型是否实现了某个接口 示例代码：

go
package main

import "fmt"

// 定义接口
type Reader interface {
    Read() string
}

// 定义类型
type File struct {
    Path string
}

// 值接收者实现接口
func (f File) Read() string {
    return "Reading from " + f.Path
}

func main() {
    var r Reader
    
    // 值类型实现了接口
    f := File{Path: "/tmp/file.txt"}
    r = f
    fmt.Println(r.Read())
    
    // 指针类型也实现了接口
    pf := &File{Path: "/tmp/file.txt"}
    r = pf
    fmt.Println(r.Read())
}

5.2 场景描述：方法调用选择 ​

使用方法：根据变量的类型选择合适的方法调用 示例代码：

go
package main

import "fmt"

type Counter struct {
    Value int
}

// 值接收者方法
func (c Counter) GetValue() int {
    return c.Value
}

// 指针接收者方法
func (c *Counter) Increment() {
    c.Value++
}

func main() {
    // 值类型
    c := Counter{Value: 0}
    fmt.Println("Initial value:", c.GetValue())
    
    // 值类型调用指针接收者方法（编译器自动取地址）
    c.Increment()
    fmt.Println("After increment:", c.GetValue())
    
    // 指针类型
    pc := &Counter{Value: 0}
    fmt.Println("Initial value:", pc.GetValue())
    
    // 指针类型调用指针接收者方法
    pc.Increment()
    fmt.Println("After increment:", pc.GetValue())
}

5.3 场景描述：接口变量的方法调用 ​

使用方法：通过接口变量调用方法，实现多态 示例代码：

go
package main

import "fmt"

// 定义接口
type Shape interface {
    Area() float64
    Perimeter() float64
}

// 定义圆形
type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
    return 2 * 3.14 * c.Radius
}

// 定义矩形
type Rectangle struct {
    Width  float64
    Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

// 使用接口
func PrintShapeInfo(s Shape) {
    fmt.Printf("Area: %.2f, Perimeter: %.2f\n", s.Area(), s.Perimeter())
}

func main() {
    // 圆形
    circle := Circle{Radius: 5}
    PrintShapeInfo(circle)
    
    // 矩形
    rectangle := Rectangle{Width: 4, Height: 6}
    PrintShapeInfo(rectangle)
}

5.4 场景描述：类型断言与方法集 ​

使用方法：通过类型断言获取具体类型，调用其方法 示例代码：

go
package main

import "fmt"

// 定义接口
type Animal interface {
    Speak() string
}

// 定义狗
type Dog struct {
    Name string
}

func (d Dog) Speak() string {
    return "Woof!"
}

func (d Dog) Fetch() string {
    return "Fetching ball"
}

// 定义猫
type Cat struct {
    Name string
}

func (c Cat) Speak() string {
    return "Meow!"
}

func (c Cat) Purr() string {
    return "Purring"
}

func main() {
    var a Animal
    
    // 狗
    a = Dog{Name: "Fido"}
    fmt.Println(a.Speak())
    
    // 类型断言获取具体类型
    if dog, ok := a.(Dog); ok {
        fmt.Println(dog.Fetch())
    }
    
    // 猫
    a = Cat{Name: "Whiskers"}
    fmt.Println(a.Speak())
    
    // 类型断言获取具体类型
    if cat, ok := a.(Cat); ok {
        fmt.Println(cat.Purr())
    }
}

5.5 场景描述：方法集与反射 ​

使用方法：通过反射获取类型的方法集 示例代码：

go
package main

import (
    "fmt"
    "reflect"
)

type T struct {
    Value int
}

func (t T) ValueMethod() {
    fmt.Println("ValueMethod")
}

func (t *T) PointerMethod() {
    fmt.Println("PointerMethod")
}

func main() {
    // 获取值类型的方法集
    tType := reflect.TypeOf(T{})
    fmt.Println("Value type methods:")
    for i := 0; i < tType.NumMethod(); i++ {
        method := tType.Method(i)
        fmt.Println(" ", method.Name)
    }
    
    // 获取指针类型的方法集
    ptType := reflect.TypeOf(&T{})
    fmt.Println("Pointer type methods:")
    for i := 0; i < ptType.NumMethod(); i++ {
        method := ptType.Method(i)
        fmt.Println("  ", method.Name)
    }
}

6. 企业级进阶应用场景 ​

6.1 场景描述：接口设计与方法集 ​

使用方法：设计接口时考虑方法集的影响 示例代码：

go
// 设计原则：接口应该小而专一
// 这样可以让更多类型实现接口

type Logger interface {
    Log(message string)
}

type Metrics interface {
    Record(name string, value float64)
}

// 组合接口
type Monitor interface {
    Logger
    Metrics
}

// 实现接口
type ConsoleMonitor struct{}

func (cm *ConsoleMonitor) Log(message string) {
    fmt.Println("[LOG]", message)
}

func (cm *ConsoleMonitor) Record(name string, value float64) {
    fmt.Printf("[METRIC] %s: %.2f\n", name, value)
}

// 使用接口
type Service struct {
    monitor Monitor
}

func NewService(monitor Monitor) *Service {
    return &Service{monitor: monitor}
}

func (s *Service) Process() {
    s.monitor.Log("Processing started")
    // 处理逻辑
    s.monitor.Record("processing_time", 1.23)
    s.monitor.Log("Processing completed")
}

6.2 场景描述：依赖注入与方法集 ​

使用方法：通过方法集实现依赖注入 示例代码：

go
// 定义存储接口
type Storage interface {
    Save(key string, value interface{}) error
    Get(key string) (interface{}, error)
    Delete(key string) error
}

// 实现内存存储
type InMemoryStorage struct {
    data map[string]interface{}
    mutex sync.RWMutex
}

func NewInMemoryStorage() *InMemoryStorage {
    return &InMemoryStorage{
        data: make(map[string]interface{}),
    }
}

func (s *InMemoryStorage) Save(key string, value interface{}) error {
    s.mutex.Lock()
    defer s.mutex.Unlock()
    s.data[key] = value
    return nil
}

func (s *InMemoryStorage) Get(key string) (interface{}, error) {
    s.mutex.RLock()
    defer s.mutex.RUnlock()
    if value, ok := s.data[key]; ok {
        return value, nil
    }
    return nil, errors.New("key not found")
}

func (s *InMemoryStorage) Delete(key string) error {
    s.mutex.Lock()
    defer s.mutex.Unlock()
    delete(s.data, key)
    return nil
}

// 定义服务
type UserService struct {
    storage Storage
}

func NewUserService(storage Storage) *UserService {
    return &UserService{storage: storage}
}

func (s *UserService) CreateUser(user User) error {
    return s.storage.Save(user.ID, user)
}

func (s *UserService) GetUser(id string) (User, error) {
    value, err := s.storage.Get(id)
    if err != nil {
        return User{}, err
    }
    user, ok := value.(User)
    if !ok {
        return User{}, errors.New("invalid user data")
    }
    return user, nil
}

func (s *UserService) DeleteUser(id string) error {
    return s.storage.Delete(id)
}

7. 行业最佳实践 ​

7.1 实践内容：保持方法接收者类型一致 ​

推荐理由：对于同一个类型，方法集应该使用一致的接收者类型，提高代码的可读性和可维护性

7.2 实践内容：优先使用指针接收者 ​

推荐理由：指针接收者可以避免值拷贝，提高性能，并且可以修改接收者的状态

7.3 实践内容：接口设计要小而专一 ​

推荐理由：小而专一的接口更容易实现，也更灵活，可以被更多类型实现

7.4 实践内容：理解方法集与接口实现的关系 ​

推荐理由：正确理解方法集的规则，可以避免接口实现的错误判断

7.5 实践内容：使用反射检查方法集 ​

推荐理由：在需要动态检查类型的方法集时，可以使用反射来获取方法信息

8. 常见问题答疑（FAQ） ​

8.1 问题描述：值类型和指针类型的方法集有什么区别？ ​

回答内容：值类型的方法集包含所有值接收者方法；指针类型的方法集包含所有值接收者方法和指针接收者方法 示例代码：

go
type T struct {
    Value int
}

func (t T) ValueMethod() {}
func (t *T) PointerMethod() {}

func main() {
    t := T{}
    pt := &T{}
    
    // 值类型可以调用
    t.ValueMethod()
    t.PointerMethod() // 编译器自动取地址
    
    // 指针类型可以调用
    pt.ValueMethod() // 编译器自动解引用
    pt.PointerMethod()
}

8.2 问题描述：如何判断一个类型是否实现了某个接口？ ​

回答内容：当一个类型的方法集包含接口的所有方法时，该类型实现了接口 示例代码：

go
type I interface {
    Method()
}

type T struct {}

// 值接收者实现接口
func (t T) Method() {}

func main() {
    var i I
    
    // 值类型实现了接口
    t := T{}
    i = t
    
    // 指针类型也实现了接口
    pt := &T{}
    i = pt
}

8.3 问题描述：当使用指针接收者实现接口时，值类型是否实现了该接口？ ​

回答内容：当使用指针接收者实现接口时，值类型的方法集不包含该方法，因此值类型没有实现该接口 示例代码：

go
type I interface {
    Method()
}

type T struct {}

// 指针接收者实现接口
func (t *T) Method() {}

func main() {
    var i I
    
    // 错误：值类型没有实现接口
    // t := T{}
    // i = t
    
    // 正确：指针类型实现了接口
    pt := &T{}
    i = pt
}

8.4 问题描述：方法集与接口组合有什么关系？ ​

回答内容：接口组合时，组合接口的方法集是所有被组合接口方法集的并集。一个类型要实现组合接口，必须实现所有被组合接口的所有方法 示例代码：

go
type Reader interface {
    Read() string
}

type Writer interface {
    Write(data string)
}

// 组合接口
type ReadWriter interface {
    Reader
    Writer
}

type File struct{}

// 实现 Reader 接口
func (f File) Read() string {
    return "data"
}

// 实现 Writer 接口
func (f File) Write(data string) {
    fmt.Println("Writing:", data)
}

func main() {
    var rw ReadWriter
    f := File{}
    rw = f // 正确：File 实现了 ReadWriter 接口
}

8.5 问题描述：方法集与类型嵌入有什么关系？ ​

回答内容：当一个类型嵌入另一个类型时，嵌入类型的方法会被提升到外部类型的方法集中。外部类型的方法集包含自身的方法和嵌入类型的方法 示例代码：

go
type Base struct{}

func (b Base) BaseMethod() {}

func (b *Base) BasePointerMethod() {}

type Derived struct {
    Base
}

func (d Derived) DerivedMethod() {}

func main() {
    d := Derived{}
    pd := &Derived{}
    
    // 值类型的方法集：DerivedMethod, BaseMethod
    d.DerivedMethod()
    d.BaseMethod()
    
    // 指针类型的方法集：DerivedMethod, BaseMethod, BasePointerMethod
    pd.DerivedMethod()
    pd.BaseMethod()
    pd.BasePointerMethod()
}

8.6 问题描述：如何通过反射获取类型的方法集？ ​

回答内容：使用 reflect.Type 的 NumMethod() 和 Method() 方法获取类型的方法集 示例代码：

go
func main() {
    t := reflect.TypeOf(T{})
    fmt.Println("Value type methods:")
    for i := 0; i < t.NumMethod(); i++ {
        fmt.Println("  ", t.Method(i).Name)
    }
    
    pt := reflect.TypeOf(&T{})
    fmt.Println("Pointer type methods:")
    for i := 0; i < pt.NumMethod(); i++ {
        fmt.Println("  ", pt.Method(i).Name)
    }
}

9. 实战练习 ​

9.1 基础练习：方法集与接口实现 ​

解题思路：创建一个接口，然后分别用值接收者和指针接收者实现，测试接口实现情况 常见误区：错误地认为值类型和指针类型的接口实现是等价的 分步提示：

  1. 定义一个 Printer 接口，包含 Print() 方法
  2. 定义一个 Document 结构体
  3. 用值接收者实现 Printer 接口
  4. 测试值类型和指针类型是否都实现了接口
  5. 重新用指针接收者实现 Printer 接口
  6. 测试值类型和指针类型是否都实现了接口 参考代码：
go
package main

import "fmt"

// 定义接口
type Printer interface {
    Print()
}

// 定义结构体
type Document struct {
    Content string
}

// 值接收者实现接口
func (d Document) Print() {
    fmt.Println("Printing:", d.Content)
}

// 指针接收者实现接口
// func (d *Document) Print() {
//     fmt.Println("Printing:", d.Content)
// }

func main() {
    var p Printer
    
    // 测试值类型
    doc := Document{Content: "Hello, World!"}
    
    // 当使用值接收者时，值类型实现了接口
    p = doc
    p.Print()
    
    // 当使用值接收者时，指针类型也实现了接口
    p = &doc
    p.Print()
    
    // 当使用指针接收者时，值类型没有实现接口
    // p = doc // 编译错误
    
    // 当使用指针接收者时，指针类型实现了接口
    // p = &doc
    // p.Print()
}

9.2 进阶练习：方法集与类型嵌入 ​

解题思路：创建一个基础类型，然后通过类型嵌入创建一个派生类型，测试方法集的提升 常见误区：不理解嵌入类型方法的提升规则 分步提示：

  1. 定义一个 Base 结构体，包含值接收者方法和指针接收者方法
  2. 定义一个 Derived 结构体，嵌入 Base 结构体
  3. 为 Derived 结构体添加自己的方法
  4. 测试值类型和指针类型的方法集 参考代码：
go
package main

import "fmt"

// 基础结构体
type Base struct {
    BaseValue int
}

// 值接收者方法
func (b Base) BaseValueMethod() {
    fmt.Println("BaseValueMethod called")
}

// 指针接收者方法
func (b *Base) BasePointerMethod() {
    fmt.Println("BasePointerMethod called")
}

// 派生结构体
type Derived struct {
    Base
    DerivedValue int
}

// 值接收者方法
func (d Derived) DerivedValueMethod() {
    fmt.Println("DerivedValueMethod called")
}

// 指针接收者方法
func (d *Derived) DerivedPointerMethod() {
    fmt.Println("DerivedPointerMethod called")
}

func main() {
    // 值类型
    d := Derived{}
    fmt.Println("Value type:")
    d.BaseValueMethod()     // 提升的 Base 值方法
    d.DerivedValueMethod()  // Derived 值方法
    
    // 指针类型
    pd := &Derived{}
    fmt.Println("Pointer type:")
    pd.BaseValueMethod()      // 提升的 Base 值方法
    pd.BasePointerMethod()     // 提升的 Base 指针方法
    pd.DerivedValueMethod()    // Derived 值方法
    pd.DerivedPointerMethod()  // Derived 指针方法
}

9.3 挑战练习：方法集与依赖注入 ​

解题思路：创建一个依赖注入系统，使用接口和方法集实现服务的注册和解析 常见误区：依赖注入系统设计过于复杂，没有充分利用接口和方法集 分步提示：

  1. 定义一个 Container 接口，包含注册和解析方法
  2. 实现一个 SimpleContainer 结构体，实现 Container 接口
  3. 定义一些服务接口和实现
  4. 使用容器注册和解析服务
  5. 测试依赖注入的效果 参考代码：
go
package main

import (
    "errors"
    "fmt"
    "reflect"
)

// 容器接口
type Container interface {
    Register(name string, service interface{}) error
    Resolve(name string, dest interface{}) error
}

// 简单容器实现
type SimpleContainer struct {
    services map[string]interface{}
}

// 创建容器
func NewContainer() *SimpleContainer {
    return &SimpleContainer{
        services: make(map[string]interface{}),
    }
}

// 注册服务
func (c *SimpleContainer) Register(name string, service interface{}) error {
    c.services[name] = service
    return nil
}

// 解析服务
func (c *SimpleContainer) Resolve(name string, dest interface{}) error {
    service, ok := c.services[name]
    if !ok {
        return errors.New("service not found")
    }
    
    destValue := reflect.ValueOf(dest).Elem()
    serviceValue := reflect.ValueOf(service)
    
    if !serviceValue.Type().AssignableTo(destValue.Type()) {
        return errors.New("service type mismatch")
    }
    
    destValue.Set(serviceValue)
    return nil
}

// 服务接口
type Logger interface {
    Log(message string)
}

type Database interface {
    Query(sql string) string
}

// 服务实现
type ConsoleLogger struct{}

func (cl *ConsoleLogger) Log(message string) {
    fmt.Println("[LOG]", message)
}

type MySQLDatabase struct{}

func (db *MySQLDatabase) Query(sql string) string {
    return "Query result for: " + sql
}

// 业务服务
type UserService struct {
    logger Logger
    db     Database
}

func NewUserService(logger Logger, db Database) *UserService {
    return &UserService{
        logger: logger,
        db:     db,
    }
}

func (s *UserService) GetUser(id string) {
    s.logger.Log("Getting user: " + id)
    result := s.db.Query("SELECT * FROM users WHERE id = " + id)
    s.logger.Log(result)
}

func main() {
    // 创建容器
    container := NewContainer()
    
    // 注册服务
    container.Register("logger", &ConsoleLogger{})
    container.Register("db", &MySQLDatabase{})
    
    // 解析服务
    var logger Logger
    container.Resolve("logger", &logger)
    
    var db Database
    container.Resolve("db", &db)
    
    // 创建业务服务
    userService := NewUserService(logger, db)
    
    // 使用业务服务
    userService.GetUser("123")
}

10. 知识点总结 ​

10.1 核心要点 ​

  • 方法集：一个类型所有可调用的方法的集合
  • 值类型方法集：包含所有值接收者方法
  • 指针类型方法集：包含所有值接收者方法和指针接收者方法
  • 接口实现：当一个类型的方法集包含接口的所有方法时，该类型实现了接口
  • 自动转换：Go 语言会在值和指针之间自动转换，使方法调用更加灵活
  • 类型嵌入：嵌入类型的方法会被提升到外部类型的方法集中
  • 反射：可以通过反射获取类型的方法集信息

10.2 易错点回顾 ​

  • 接口实现判断：当使用指针接收者实现接口时，值类型没有实现该接口
  • 方法调用：值类型可以调用指针接收者方法（编译器自动取地址），指针类型可以调用值接收者方法（编译器自动解引用）
  • 方法集提升：嵌入类型的方法会被提升到外部类型的方法集中
  • 接收者类型一致性：同一个类型的方法应该使用一致的接收者类型
  • 接口设计：接口应该小而专一，便于实现和使用

11. 拓展参考资料 ​

11.1 官方文档链接 ​

11.2 进阶学习路径建议 ​

  • 反射：深入理解 Go 语言的反射机制，了解如何动态检查和调用方法
  • 泛型：学习 Go 1.18+ 的泛型特性，了解泛型与方法集的关系
  • 接口设计模式：学习常见的接口设计模式，如依赖注入、策略模式等
  • 类型系统：深入理解 Go 语言的类型系统，包括类型断言、类型转换等
  • 并发编程：了解方法集在并发编程中的应用，如互斥锁、通道等

11.3 推荐书籍和资源 ​

  • 《Go 程序设计语言》：详细介绍了 Go 语言的方法集和接口实现
  • 《Go 语言实战》：包含了大量关于方法集和接口的实战示例
  • Go 官方博客：有关方法集和接口的深入文章
  • Go Playground：在线测试方法集和接口实现的代码

12. 总结 ​

方法集是 Go 语言类型系统的重要组成部分，它决定了一个类型可以调用哪些方法，以及是否实现了某个接口。通过理解方法集的规则，我们可以更好地设计接口，实现代码的复用和扩展。在实际开发中，合理使用方法集可以使代码更加灵活、高效和可维护。

本知识点是 Go 语言面向对象编程的总结性内容，通过学习方法集，我们可以将之前学到的结构体、接口、类型嵌入等知识点串联起来，形成完整的面向对象编程体系。