go 语言不支持传统面向对象的继承机制，但可通过嵌入指针字段让子结构体“持有”父结构体引用，从而间接调用其方法；本文详解该模式的实现方式、关键注意事项及完整可运行示例。
go 语言不支持传统面向对象的继承机制，但可通过嵌入指针字段让子结构体“持有”父结构体引用，从而间接调用其方法；本文详解该模式的实现方式、关键注意事项及完整可运行示例。
在 Go 中，结构体之间没有 extends 或 super 等继承语法，因此无法像 Java 或 Python 那样直接通过 super.Remember() 调用父级方法。但我们可以借助
组合（Composition）+ 指针引用
的方式，模拟“子调用父”的行为——核心思想是：
让子结构体持有一个指向父结构体的指针，并通过该指针调用其公开方法
。
以下是一个清晰、实用的实现方案：
?
关键要点与注意事项
：
*
必须使用指针类型 `
parent**：若定义为parent值类型，每次赋值都会拷贝整个父结构体，不仅低效，且修改c.parent.Memory不会影响原始p；而*parent` 确保所有 child 共享同一 parent 实例。
初始化不可遗漏
：child.parent = &p 必须显式赋值，Go 不会自动关联；未初始化的指针为 nil，直接调用会导致 panic（如 nil pointer dereference），因此建议在 Yell() 等方法中加 if c.parent != nil 防御性检查。
避免循环引用导致 GC 困难
：当前设计中，parent 包含 []child（值类型切片），而每个 child 又持有 *parent，这本身
不构成强循环引用
（因 child 是值，parent 不持有 *child），故不会阻碍垃圾回收；但若后续改为 Children []*child 且 parent 又被 child 强引用，则需谨慎评估生命周期。
替代方案对比
：
使用接口抽象行为（如定义 Rememberer 接口）可提升解耦性；
若逻辑高度复用，可将共通方法提取为独立函数，接收 *parent 作为参数；
嵌入（embedding）适用于“has-a”关系，但无法解决跨结构体方法调用问题，此处不适用。
✅ 总结：Go 的哲学是“组合优于继承”。通过显式维护父子指针关系，我们既能保持代码清晰可控，又能安全、高效地实现类似“子调父”的协作模式——这正是 Go 风格面向对象的典型实践。
package main
import "fmt"
type child struct {
Name string
parent *parent // 关键：添加指向 parent 的指针字段
}
func (c *child) Yell() {
fmt.Println("Child's yelling")
if c.parent != nil {
c.parent.Remember(c.Name + " yelled") // ✅ 通过指针调用父方法
c.parent.Yell() // ✅ 同样可调用其他方法
}
}
type parent struct {
Name string
Children []child
Memory []string
}
func (p *parent) Yell() {
fmt.Println("Parent's yelling")
}
func (p *parent) Remember(line string) {
p.Memory = append(p.Memory, line)
}
func main() {
p := parent{
Name: "Jon",
}
boy1 := child{
Name: "Jon's boy",
parent: &p, // ✅ 必须在初始化时赋值指针
}
girl1 := child{
Name: "Jon's girl",
parent: &p,
}
p.Children = append(p.Children, boy1, girl1)
p.Yell()
for _, c := range p.Children {
c.Yell()
}
fmt.Printf("Parent's memory: %v\n", p.Memory)
// 输出: Parent's memory: [Jon's boy yelled Jon's girl yelled]
}