如何在Go语言中实现此类类层级结构，使子类方法被正确调用？

给定如下Go代码：

package main

type barer interface {
    bar()
}

// 实际上base是复杂类型，包含大量成员和方法作为基础实现
type base struct {
    barer
}

func (b *base) foo() {
    print("foo call: ")
    b.bar()
}

// 期望作为默认实现，如果derive没有实现bar则使用这个
func (b *base) bar() {
    println("base bar")
}

func main() {
    var d1 derive1
    d1.barer = &d1
    var d2 derive2
    d2.barer = &d2

    // bases作为管理器，管理多个已注册的deriveN实例
    bases := []*base{&d1.base, &d2.base}
    for _, b := range bases {
        b.foo()
    }
}

// derive1嵌入base，复用base的内部实现
type derive1 struct {
    base
}

// 重写bar方法
func (d *derive1) bar() {
    println("derive1 bar")
}

// derive2嵌入base，复用base的内部实现
type derive2 struct {
    base
}

// 重写bar方法
func (d *derive2) bar() {
    println("derive2 bar")
}

当前代码无法正确调用derive1和derive2的bar方法，原因是Go并非纯面向对象语言，方法解析时会优先选择base自身的bar方法，而非嵌入接口中保存的子类实现。需实现类似类层级/组合结构，让子类的bar方法能被正确调用（类似基础窗口类与业务窗口类的关系：基础类实现通用逻辑，子类仅实现业务相关方法）。

方案1：移除base自身的bar方法，确保调用接口实现 #

将base的默认bar实现抽离为单独类型，让base完全通过嵌入的barer接口调用方法，触发多态行为：

package main

type barer interface {
    bar()
}

// 默认实现barer的类型
type defaultBarer struct{}

func (d *defaultBarer) bar() {
    println("base bar")
}

type base struct {
    barer
}

func (b *base) foo() {
    print("foo call: ")
    b.barer.bar() // 明确调用接口方法，避免与base自身方法冲突
}

// 初始化base的辅助函数，默认使用defaultBarer
func newBase(b barer) *base {
    if b == nil {
        b = &defaultBarer{}
    }
    return &base{barer: b}
}

func main() {
    d1 := derive1{base: *newBase(&d1)}
    d2 := derive2{base: *newBase(&d2)}

    bases := []*base{&d1.base, &d2.base}
    for _, b := range bases {
        b.foo()
    }
}

type derive1 struct {
    base
}

func (d *derive1) bar() {
    println("derive1 bar")
}

type derive2 struct {
    base
}

func (d *derive2) bar() {
    println("derive2 bar")
}

方案2：使用接口统一管理实例，而非[]*base #

定义包含核心行为的接口，让base和derive都实现该接口，直接管理接口切片：

package main

type window interface {
    foo()
    bar()
}

type base struct{}

func (b *base) foo() {
    print("foo call: ")
}

// 默认bar实现
func (b *base) bar() {
    println("base bar")
}

type derive1 struct {
    base
}

func (d *derive1) bar() {
    println("derive1 bar")
}

type derive2 struct {
    base
}

func (d *derive2) bar() {
    println("derive2 bar")
}

func main() {
    windows := []window{&derive1{}, &derive2{}}
    for _, w := range windows {
        w.foo()
        w.bar()
    }
}

方案3：让base持有子类实例引用（组合而非嵌入） #

让base通过字段持有子类的接口引用，明确调用子类方法：

package main

type barer interface {
    bar()
}

type base struct {
    child barer
}

func (b *base) foo() {
    print("foo call: ")
    b.child.bar()
}

// 默认bar实现
func defaultBar() {
    println("base bar")
}

type derive1 struct{}

func (d *derive1) bar() {
    println("derive1 bar")
}

func (d *derive1) Foo() {
    base{child: d}.foo()
}

type derive2 struct{}

func (d *derive2) bar() {
    println("derive2 bar")
}

func (d *derive2) Foo() {
    base{child: d}.foo()
}

func main() {
    d1 := derive1{}
    d2 := derive2{}

    d1.Foo()
    d2.Foo()

    // 统一管理实例
    type foobar interface {
        Foo()
    }
    items := []foobar{&d1, &d2}
    for _, item := range items {
        item.Foo()
    }
}

关键说明 #

• Go的嵌入是组合语法糖，并非传统OOP的继承，方法解析优先值类型本身的方法，而非嵌入字段/接口的方法。
• 要实现多态，必须依赖接口：通过接口类型调用方法，才能触发不同实现的行为。
• 对于基础类+业务类的场景，推荐使用接口定义行为+组合复用基础逻辑的方式，既保留Go的简洁性，又能实现类似继承的效果。

内容的提问来源于stack exchange，提问作者api