Go 语言的接口、结构体嵌入和多态性概念

Go 语言的接口、结构体嵌入和多态性概念，使用「动物」这个容易理解的场景进行演示：

package main

import "fmt"

// ================= 接口定义 =================
// 接口 (Interface):
// Animal 接口定义了动物的基本行为
// Go 的接口是隐式实现的，只要类型实现了接口定义的方法就自动满足

//无需显式声明：类型（如结构体）不需要像 Java 或 C# 那样用 implements 关键字声明自己实现了某个接口。
//自动满足：只要一个类型实现了接口定义的全部方法，它就被视为实现了该接口，编译器自动识别。
//解耦设计：接口和实现之间没有直接的代码级依赖，通过方法签名隐式关联。

//Go 的隐式接口实现通过方法签名匹配和鸭子类型机制：
//方法签名匹配：接口与类型的关联完全基于方法签名（方法名、参数列表、返回值）的匹配。
//鸭子类型（Duck Typing）："如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子"。只要行为匹配，类型即实现接口。


type Animal interface {
    Speak() string
    GetName() string // 演示结构体嵌入时使用
}

// ================= 基础结构体 =================
//底层原理剖析
//1. 接口的静态类型与动态值
//接口变量包含两部分：
//动态类型（Concrete Type）：实际存储的值的类型（如 Dog 或 Pet ）。
//动态值（Concrete Value）：实际存储的值。
//赋值过程：当将 Pet{} 赋值给 Animal 接口变量时，编译器检查 Pet 是否实现了 Animal 的所有方法。
//如果类型未实现接口的全部方法，编译器会报错

//2. 方法表（Method Table）
//接口方法调用本质：
//每个接口内部维护一个方法表（类似于虚函数表）。
//当调用 a.Speak() 时，Go 运行时根据动态类型的方法表找到具体的实现方法。

//动态分派：在运行时根据实际类型决定调用哪个方法。


type Pet struct {
    name string
}


//Pet结构体实现了 GetName()的方法，编译器会自动认为Pet结构体满足Animal interface
func (p *Pet) GetName() string {
    return p.name
}

// ================= 具体动物类型 =================
//Dog 通过嵌入 Pet 结构体，继承了 Pet 的 GetName() 方法，因此 Dog 也隐式实现了 Animal 接口。
//接口的传递性：组合后的类型依然通过隐式方法匹配实现接口。

type Dog struct {
    Pet          // 嵌入 Pet 结构体（组合）
    Breed string // 品种字段
}

func (d *Dog) Speak() string {
    return "Woof! My name is " + d.name
}

type Cat struct {
    Pet
    Color string // 颜色字段
}

func (c *Cat) Speak() string {
    return "Meow! I'm " + c.name
}

// ================= 多态演示函数 =================
func AnimalInfo(a Animal) {
    fmt.Printf("[%s] says: %s\n", a.GetName(), a.Speak())
}

// ================= 特殊类型演示接口扩展 =================
type LoudAnimal struct {
    Animal // 嵌入接口类型
}

func (la *LoudAnimal) Speak() string {
    return "!!! " + la.Animal.Speak() + " !!!"
}

func main() {
    // 创建实例
    dog := &Dog{
        Pet:   Pet{name: "Buddy"},
        Breed: "Golden Retriever",
    }
    
    cat := &Cat{
        Pet:   Pet{name: "Luna"},
        Color: "Calico",
    }

    // 多态性演示
    animals := []Animal{dog, cat}
    for _, a := range animals {
        AnimalInfo(a)
    }

    // 结构体嵌入演示
    fmt.Println("\nDog's name through embedded struct:", dog.name)
    fmt.Println("Cat's name through method:", cat.GetName())

    // 接口扩展演示
    loudDog := &LoudAnimal{Animal: dog}
    fmt.Println("\nLoud animal:", loudDog.Speak())
}

---

1. 接口 (Interface):

• Animal 接口定义了动物的基本行为

• Go 的接口是隐式实现的，只要类型实现了接口定义的方法就自动满足

• 输出结果：

[Buddy] says: Woof! My name is Buddy
[Luna] says: Meow! I'm Luna

2. 结构体嵌入 (Embedding):

• Dog 和 Cat 通过嵌入 Pet 结构体获得 name 字段和 GetName() 方法

• 嵌入可以实现类似继承的效果，但本质是组合（composition）

• 访问方式演示：

Dog's name through embedded struct: Buddy
Cat's name through method: Luna

3. 多态性 (Polymorphism):

• 多态性通过接口的隐式实现和动态派发（Dynamic Dispatch）机制实现。

• Go语言的接口变量本质上是一个二元组（其中itab包含类型信息和方法表）。当类型实现接口方法时，编译器自动生成itab，自动记录了itab信息。方法调用时通过itab动态查找具体实现。

• AnimalInfo 函数可以处理任何实现了 Animal 接口的类型

• 通过接口类型切片 []Animal 统一处理不同动物类型

• 输出时自动调用各自具体的 Speak() 实现

4. 接口扩展技巧:

• LoudAnimal 通过嵌入接口类型实现功能扩展

• 重写 Speak() 方法时调用了嵌入接口的原始方法

• 输出：

Loud animal: !!! Woof! My name is Buddy !!!

关键概念总结表：

概念	特点	示例位置
接口	定义方法集合，隐式实现	Animal 接口
结构体嵌入	通过组合复用代码，可以嵌入结构体或接口	Dog/Cat 中的 Pet 嵌入
多态性	通过接口类型实现统一处理不同具体类型	AnimalInfo 函数
接口扩展	通过嵌入接口类型实现装饰器模式	LoudAnimal 结构体