Go语言通过结构体嵌入实现组合而非继承：匿名嵌入自动提升可导出字段和方法，具名嵌入需显式访问；可定义同名方法覆盖行为，嵌入接口使类型自动满足契约。
Go 语言中没有传统意义上的“继承”，但通过结构体嵌套（也称“组合”）可以自然、灵活地复用字段和方法，构建复合数据类型。核心思路是：将一个结构体作为另一个结构体的匿名或具名字段嵌入，从而获得其字段和可导出方法。
匿名嵌入：实现“类似继承”的简洁组合
匿名嵌入是最常用的方式。被嵌入的结构体类型不写字段名，Go 会自动将其所有**可导出字段和方法**提升到外层结构体作用域中。
- 语法：
type Outer struct { Inner }（Inner 是类型名，非变量名） - 效果：Outer 实例可直接访问 Inner 的导出字段（如
o.Field）和方法（如o.Method()） - 注意：若 Outer 自身也有同名字段/方法，会遮蔽（shadow）嵌入结构体的成员
示例：
type Person struct {
Name string
Age int
}
func (p Person) Greet() string {
return "Hello, " + p.Name
}
type Employee struct {
Person // 匿名嵌入
ID int
Dept string
}
func main() {
e := Employee{
Person: Person{Name: "Alice", Age: 30},
ID: 1001,
Dept: "Engineering",
}
fmt.Println(e.Name) // ✅ 直接访问嵌入字段
fmt.Println(e.Greet()) // ✅ 直接调用嵌入方法
fmt.Println(e.ID) // ✅ 访问自身字段
}
具名嵌入：明确归属，避免命名冲突
当多个嵌入结构体存在同名字段，或你希望语义更清晰时，使用具名嵌入。
立即学习“go语言免费学习笔记（深入）”；
- 语法：
type Outer struct { InnerType InnerField } - 访问方式变为
o.InnerField.Field或o.InnerField.Method() - 不会自动提升字段/方法，完全按字段名隔离，适合复杂组合场景
示例：
type ContactInfo struct {
Email string
Phone string
}
type Address struct {
City string
Zip string
}
type User struct {
Person // 匿名，共享 Name/Age
Contact ContactInfo // 具名
Location Address // 具名
}
func main() {
u := User{
Person: Person{Name: "Bob", Age: 25},
Contact: ContactInfo{Email: "bob@example.com"},
Location: Address{City: "Shanghai"},
}
fmt.Println(u.Name) // ✅ 来自 Person
fmt.Println(u.Contact.Email) // ✅ 必须通过 Contact 访问
fmt.Println(u.Location.City) // ✅ 必须通过 Location 访问
}
方法重写与组合扩展
嵌入不是继承，不支持“重写父类方法”。但你可以为外层结构体定义同名方法，实现逻辑覆盖——这本质是新方法，与嵌入结构体的方法无关。
- 嵌入结构体的方法仍存在，可通过显式路径调用：
e.Person.Greet() - 外层定义的同名方法会优先被调用（因方法集属于该类型）
- 这是组合优于继承的体现：行为复用 + 明确覆盖，无隐式调用链
示例：
func (e Employee) Greet() string {
return "Hi, I'm " + e.Name + ", employee #" + strconv.Itoa(e.ID)
}
func main() {
e := Employee{Person: Person{Name: "Charlie"}, ID: 2002}
fmt.Println(e.Greet()) // ? 调用 Employee.Greet()
fmt.Println(e.Person.Greet()) // ? 显式调用 Person.Greet()
}
嵌入接口：组合行为契约
你还可以嵌入接口类型，使外层结构体“自动满足”该接口（只要它实现了接口所有方法），常用于依赖注入或策略模式。
- 嵌入接口后，外层结构体无需显式声明实现，只要方法集完备即自动满足
- 适合解耦组件行为，比如日志器、存储器、验证器等可插拔模块
示例：
type Logger interface {
Log(msg string)
}
type FileLogger struct{}
func (f FileLogger) Log(msg string) { fmt.Println("[FILE]", msg) }
type Service struct {
Logger // 嵌入接口
}
func main() {
s := Service{FileLogger{}} // 注入具体实现
s.Log("service started") // ✅ 自动满足 Logger 接口并调用
}
组合是 Go 的哲学核心——用小而专的结构体拼装大功能，清晰、可控、无歧义。写的时候想清楚：这个字段/行为是“我有一个”（具名嵌入），还是“我就是它的一部分”（匿名嵌入），就基本不会错。
