Go语言嵌入类型与默认方法：规避传统继承陷阱

package main

type MyInterface interface {
    hello() string
}

type Embedded struct {
    // ... 可以有自己的字段
}

func (e *Embedded) hello() string {
    // 理想情况下，这里能获取到嵌入者（例如Object）的Name属性
    name := "none"
    // 如何在此处获取到 Object 的 Name 属性？
    return name
}

type Object struct {
    *Embedded // 嵌入 Embedded
    Name      string
}

/*
// 期望 Object 可以选择性地覆盖 hello() 方法，
// 如果不覆盖，则使用 Embedded 提供的默认实现，
// 且该默认实现能利用 Object 的 Name。
func (o *Object) hello() string {
    return o.Name
}
*/

func main() {
    o := &Object{
        Embedded: &Embedded{}, // 实例化嵌入类型
        Name:     "My Object Name",
    }
    println("Hello world", o.hello()) // 当前会输出 "Hello world none"
}

type T struct{}
func (t T) foo() {} // t 是 T 的一个实例

type U struct {
    t T // T 被嵌入 U
}

func main() {
    var t T
    var u U
    t.foo()    // t 的 foo() 被调用
    u.t.foo()  // t 的 foo() 被调用
    // 或者通过方法提升
    // u.foo() // 如果 U 嵌入的是 *T，则可以直接调用
}

package main

import "fmt"

// NameProvider 接口定义了获取名称的方法
type NameProvider interface {
    GetName() string
}

// MyInterface 接口定义了 hello() 方法
type MyInterface interface {
    hello() string
}

// Embedded 类型，提供一个辅助方法
type Embedded struct {
    // Embedded 可以有自己的字段，但它们与嵌入者无关
}

// Greet 是 Embedded 提供的一个辅助方法，它接受一个 NameProvider 接口
// 这样它就能通过 NameProvider 获取到名称，而无需知道具体的嵌入者类型
func (e *Embedded) Greet(p NameProvider) string {
    if p != nil {
        return fmt.Sprintf("Hello from %s (via Embedded helper)", p.GetName())
    }
    return "Hello from Embedded (no specific name provided)"
}

type Object struct {
    *Embedded // 嵌入 Embedded
    Name      string
}

// Object 实现了 NameProvider 接口
func (o *Object) GetName() string {
    return o.Name
}

// Object 实现了 MyInterface 的 hello() 方法
// 它选择调用 Embedded 的辅助方法，并传入自身作为 NameProvider
func (o *Object) hello() string {
    return o.Embedded.Greet(o) // 显式传递自身上下文
}

func main() {
    o := &Object{
        Embedded: &Embedded{}, // 实例化嵌入类型
        Name:     "My Object Name",
    }
    fmt.Println(o.hello()) // 输出: Hello from My Object Name (via Embedded helper)

    // 假设有一个对象不提供 NameProvider 接口，或者 Embedded 的 Greet 方法有其他默认行为
    // 这里的关键是 Object 显式地决定了如何利用 Embedded 的功能
}

package main

import "fmt"

// MyInterface 接口定义了 hello() 方法
type MyInterface interface {
    hello() string
}

// Embedded 类型，提供一个不依赖嵌入者的默认 hello() 实现
type Embedded struct {
    // ...
}

// hello() 方法是 Embedded 的默认实现，它不依赖外部数据
func (e *Embedded) hello() string {
    return "Hello from Embedded's default implementation"
}

// Object 类型，嵌入 Embedded，并选择覆盖 hello() 方法
type Object struct {
    *Embedded // 嵌入 Embedded
    Name      string
}

// Object 实现了 MyInterface 的 hello() 方法，覆盖了 Embedded 的默认行为