如何在 Go 中实现内嵌类型默认行为并引用外部类型属性

package main

import "fmt"

type MyInterface interface {
    hello() string
}

type Embedded struct {
    // 假设这里有一些通用的逻辑或字段
}

// Embedded 的 hello 方法，目前无法直接访问 Object 的 Name
func (e *Embedded) hello() string {
    // 期望这里能返回 Object 的 Name，但直接访问是做不到的
    return "Default hello from Embedded (no name available)"
}

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

/*
// 如果 Object 不实现 hello()，则会调用 Embedded 的 hello()
// 但 Embedded 的 hello() 无法得知 Object 的 Name
func (o *Object) hello() string {
    return o.Name // 这是显式覆盖
}
*/

func main() {
    o := &Object{Name: "My Object Name"}
    o.Embedded = &Embedded{} // 确保 Embedded 实例被初始化

    fmt.Println("Hello world:", o.hello()) // 预期调用 Embedded 的 hello()
}

package main

import "fmt"

// 定义一个接口，描述 Embedded 需要从外部类型获取的能力
type Namer interface {
    GetName() string
}

type MyInterface interface {
    hello() string
}

type Embedded struct {
    // 可以有其他字段
}

// Embedded 的 hello 方法现在接受一个 Namer 接口作为参数
func (e *Embedded) hello(n Namer) string {
    // 通过 Namer 接口获取外部类型的 Name
    return fmt.Sprintf("Hello from Embedded, object name: %s", n.GetName())
}

type Object struct {
    *Embedded
    Name string
}

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

// Object 实现 MyInterface 的 hello 方法，
// 在其内部调用 Embedded 的 hello 方法并传入自身
func (o *Object) hello() string {
    // 如果需要默认行为，则调用 Embedded 的方法，并传入自身作为 Namer
    return o.Embedded.hello(o)
}

func main() {
    o := &Object{Name: "My Object Name"}
    o.Embedded = &Embedded{} // 初始化 Embedded 实例

    fmt.Println("Greeting:", o.hello())

    // 假设我们有一个需要自定义 hello 行为的类型
    type CustomObject struct {
        *Embedded
        Name string
        CustomGreeting string
    }

    // CustomObject 也可以选择覆盖 hello 方法，实现完全不同的逻辑
    func (co *CustomObject) hello() string {
        return co.CustomGreeting + " " + co.Name
    }

    co := &CustomObject{Name: "Custom Object", CustomGreeting: "Hola"}
    co.Embedded = &Embedded{}
    fmt.Println("Custom Greeting:", co.hello())

    // 如果 CustomObject 不覆盖 hello，但希望使用 Embedded 的默认行为
    // 并且 Embedded 能够访问 CustomObject 的 Name
    // 则 CustomObject 同样需要实现 Namer 接口，并在其 hello 方法中调用 Embedded 的 hello(co)
    type AnotherObject struct {
        *Embedded
        Name string
    }
    func (ao *AnotherObject) GetName() string { // 实现 Namer 接口
        return ao.Name
    }
    func (ao *AnotherObject) hello() string { // 调用 Embedded 的默认行为
        return ao.Embedded.hello(ao)
    }
    ao := &AnotherObject{Name: "Another Object"}
    ao.Embedded = &Embedded{}
    fmt.Println("Another Greeting:", ao.hello())
}

package main

import "fmt"

type Embedded struct {}

// Embedded 的 hello 方法直接接受 *Object 作为参数
func (e *Embedded) helloWithObject(o *Object) string {
    return fmt.Sprintf("Hello from Embedded, object name: %s", o.Name)
}

type Object struct {
    *Embedded
    Name string
}

// Object 的 hello 方法调用 Embedded 的 helloWithObject 并传入自身
func (o *Object) hello() string {
    return o.Embedded.helloWithObject(o)
}

func main() {
    o := &Object{Name: "My Object Name"}
    o.Embedded = &Embedded{}

    fmt.Println("Greeting:", o.hello())
}