在 go 中，通过结构体嵌入无法实现类似面向对象语言中的“子类转父类”多态行为；要统一管理不同车辆类型（如 car、bus、bike），应定义公共接口（如 vehicleer），让各类型实现该接口，再用接口切片存储实例。
在 go 中，通过结构体嵌入无法实现类似面向对象语言中的“子类转父类”多态行为；要统一管理不同车辆类型（如 car、bus、bike），应定义公共接口（如 vehicleer），让各类型实现该接口，再用接口切片存储实例。
Go 是一门强调组合与接口的静态类型语言，不支持传统意义上的继承或多态。你当前的设计中，Car、Bus、Bike 均嵌入了 Vehicle 结构体——这是一种组合（composition），而非“继承”。嵌入仅将 Vehicle 的字段和方法“提升”到外层结构体作用域，便于直接访问（如 car.NumberWheels），但并不会使 Car 成为 Vehicle 类型的值，因此无法直接放入 []Vehicle 切片中。
✅ 正确解法：定义接口，实现多态集合
首先，声明一个描述“车辆共性”的接口。接口应聚焦行为（方法），而非数据字段（Go 接口不包含字段）：
type Vehicleer interface {
NumWheels() int
NumPassengers() int
Owner() string
Type() string // 用于区分车型，非必需但实用
}
接着，为每个具体类型实现该接口：
func (c Car) NumWheels() int { return c.NumberWheels }
func (c Car) NumPassengers() int { return c.NumberPassengers }
func (c Car) Owner() string { return c.Owner }
func (c Car) Type() string { return "Car" }
func (b Bus) NumWheels() int { return b.NumberWheels }
func (b Bus) NumPassengers() int { return b.NumberPassengers }
func (b Bus) Owner() string { return b.Owner }
func (b Bus) Type() string { return "Bus" }
func (k Bike) NumWheels() int { return k.NumberWheels }
func (k Bike) NumPassengers() int { return k.NumberPassengers }
func (k Bike) Owner() string { return k.Owner }
func (k Bike) Type() string { return "Bike" }
现在即可创建统一的接口切片，并安全地遍历：
myCar := Car{Vehicle{4, 4, "Me"}, "Manual"}
myBike := Bike{Vehicle{2, 0, "Bob and I"}, false}
myBus := Bus{Vehicle{6, 30, "City Transit"}, true, "Diesel"}
vehicles := []Vehicleer{myCar, myBike, myBus} // ✅ 合法：所有类型均实现了 Vehicleer
for _, v := range vehicles {
fmt.Printf("%s: %d wheels, %d passengers, owned by %s\n",
v.Type(), v.NumWheels(), v.NumPassengers(), v.Owner())
}
// 输出示例：
// Car: 4 wheels, 4 passengers, owned by Me
// Bike: 2 wheels, 0 passengers, owned by Bob and I
// Bus: 6 wheels, 30 passengers, owned by City Transit
⚠️ 注意事项：
- ❌ 避免使用 interface{}（空接口）作为通用容器（如 []interface{}），它虽能存任意类型，但丧失类型安全与编译时检查，且需运行时类型断言才能调用方法，违背 Go 的设计哲学。
- ✅ 接口应小而专注（遵循 Interface Segregation Principle）。例如，若只需打印信息，可只定义 String() string 方法；若需启动逻辑，可加 Start() error。
- ? 嵌入仍有价值：它复用字段/方法定义，减少重复代码。但“多态容器”必须依赖接口，二者协同而非互斥。
总结：Go 的多态本质是鸭子类型（Duck Typing）——只要实现了接口所需方法，即视为该接口类型。抛弃“类继承”思维，拥抱“行为契约”设计，是写出地道 Go 代码的关键一步。
