在 go 语言中，由于不支持传统面向对象的继承机制，需通过结构体字段显式持有父级指针，并借助该指针调用父类型的方法，从而实现“子对象调用父对象方法”的语义。
在 go 语言中，由于不支持传统面向对象的继承机制，需通过结构体字段显式持有父级指针，并借助该指针调用父类型的方法，从而实现“子对象调用父对象方法”的语义。
Go 是一门强调组合而非继承的语言。它没有 extends 或 super 关键字，也不允许子类型自动获得父类型的字段和方法。但开发者可通过嵌入（embedding） 或显式引用（explicit reference） 实现类似“父子通信”的逻辑。本文聚焦于后者——即让 child 实例安全、清晰地调用所属 parent 的方法（如 Remember 和 Yell）。
✅ 正确做法：在 child 中保存 parent 指针
关键在于为 child 结构体添加一个指向 parent 的指针字段（例如 prnt *parent），并在创建 child 实例时将其初始化为对应 parent 的地址：
type child struct {
Name string
prnt *parent // 显式持有父对象指针
}
func (c *child) Yell() {
fmt.Println("Child's yelling")
if c.prnt != nil {
c.prnt.Remember("child " + c.Name + " yelled")
c.prnt.Yell()
}
}
⚠️ 注意：必须检查 c.prnt != nil，避免空指针解引用 panic。
? 完整可运行示例
package main
import "fmt"
type child struct {
Name string
prnt *parent
}
func (c *child) Yell() {
fmt.Println("Child's yelling")
if c.prnt != nil {
c.prnt.Remember("child " + c.Name + " yelled")
c.prnt.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", prnt: &p}
girl1 := child{Name: "Jon's girl", prnt: &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: [child Jon's boy yelled child Jon's girl yelled]
}
? 为什么不能用嵌入（embedding）？
有人可能尝试这样写：
type child struct {
parent // ❌ 错误：这不是“继承”，而是嵌入了一个匿名字段
Name string
}
这会导致 child 拥有 parent 的全部字段副本（值拷贝），且 child 方法无法访问外部 parent 实例的状态（如 Memory 切片）。更重要的是，child 并未与某个具体 parent 实例建立关联 —— 它只是“长得像”，而非“属于”。
✅ 正确语义是：一个 child 属于一个 parent，应共享其状态与行为 → 因此必须使用指针引用（*parent），而非嵌入或复制。
? 最佳实践建议
- 命名清晰：用 parent *parent 或 owner *parent 而非模糊的 p；
- 初始化强约束：确保 child.prnt 在构造时被赋值，可考虑封装为构造函数：
func newChild(name string, par *parent) child { return child{Name: name, prnt: par} } - 避免循环引用导致 GC 问题：本例中 parent → []child → *parent 是单向弱引用（child 不持有 parent 的所有权），Go 的垃圾回收器可正常处理；
- 若需多级关系（如祖父母），可逐层传递指针，但建议评估是否过度耦合，优先考虑事件通知、回调函数或观察者模式等更松耦合的设计。
通过显式指针引用，你不仅实现了“子调父方法”的需求，更践行了 Go 的设计哲学：明确、可控、组合优于继承。
