Go 语言中嵌入类型与默认方法：实现上下文感知行为

package main

import "fmt"

// MyInterface 定义了一个行为契约
type MyInterface interface {
    hello() string
}

// Embedded 是一个被嵌入的类型，旨在提供默认行为
type Embedded struct {
    // 假设这里可能有一些通用的属性或方法
}

// hello 方法是 Embedded 类型的默认实现
func (e *Embedded) hello() string {
    // 在这里，'e' 是 *Embedded 类型的一个实例。
    // 它无法直接访问到嵌入它的宿主类型（如 Object）的属性。
    // 如果我们想在这里返回 Object 的 Name，直接的结构体嵌入无法实现。
    return "Default hello from Embedded"
}

// Object 是宿主类型，它嵌入了 Embedded
type Object struct {
    *Embedded // 嵌入 Embedded 类型
    Name      string
}

func main() {
    o := &Object{
        Embedded: &Embedded{}, // 实例化嵌入类型
        Name:     "My Object Name",
    }

    // 调用 o.hello() 会调用 Embedded 类型的 hello() 方法
    // 因为 Object 自身没有定义 hello() 方法，Embedded 的方法被提升
    fmt.Println("Hello world:", o.hello()) // 输出: Hello world: Default hello from Embedded
}

package main

import "fmt"

// MyInterface 定义了一个行为契约
type MyInterface interface {
    hello() string
}

// EmbeddedHelper 封装了需要宿主上下文的逻辑
type EmbeddedHelper struct {
    // 可以在这里存储一些通用的、不依赖宿主上下文的属性
}

// DefaultHello 方法现在接受一个 MyInterface 接口作为参数
// 这样它就可以通过这个接口访问宿主类型的方法
func (eh *EmbeddedHelper) DefaultHello(host MyInterface) string {
    // 在这里，我们可以通过 host 参数调用 MyInterface 定义的方法
    // 但如果需要访问具体的字段，MyInterface 还需要提供相应的访问器方法
    // 假设 MyInterface 扩展以提供 Name
    if namer, ok := host.(interface{ GetName() string }); ok {
        return fmt.Sprintf("Hello from Embedded, host name: %s", namer.GetName())
    }
    return "Hello from Embedded, host name unknown"
}

// Object 是宿主类型，它包含 EmbeddedHelper
type Object struct {
    Helper *EmbeddedHelper // 包含一个 EmbeddedHelper 实例
    Name   string
}

// GetName 方法供 EmbeddedHelper 访问 Object 的 Name
func (o *Object) GetName() string {
    return o.Name
}

// Object 实现 MyInterface 的 hello() 方法
// 在这里，它可以选择调用 EmbeddedHelper 的 DefaultHello 方法，并传递自身
func (o *Object) hello() string {
    // 宿主类型在自己的方法中调用辅助方法，并显式传递自身作为上下文
    return o.Helper.DefaultHello(o) // 传递 o (实现了 MyInterface 和 GetName 接口)
}

func main() {
    o := &Object{
        Helper: &EmbeddedHelper{},
        Name:   "My Object Name",
    }

    fmt.Println("Hello world:", o.hello())

    // 另一个没有显式 Name 的对象
    anotherObject := &Object{
        Helper: &EmbeddedHelper{},
        Name:   "Another Object",
    }
    fmt.Println("Another hello:", anotherObject.hello())
}

package main

import "fmt"

// Namer 接口定义了获取名称的能力
type Namer interface {
    GetName() string
}

// MyInterface 定义了核心行为
type MyInterface interface {
    hello() string
}

// DefaultHelloProvider 结构体，其方法提供默认实现
type DefaultHelloProvider struct{}

// GetDefaultHello 方法接受一个 Namer 接口作为参数
// 这样它就可以获取宿主对象的名称，而无需知道宿主对象的具体类型
func (dhp *DefaultHelloProvider) GetDefaultHello(namer Namer) string {
    if namer != nil {
        return fmt.Sprintf("Hello from Default, my name is %s", namer.GetName())
    }
    return "Hello from Default, name unknown"
}

// Object 宿主类型
type Object struct {
    // 可以选择嵌入 DefaultHelloProvider，但其方法不会自动感知宿主
    // *DefaultHelloProvider // 如果嵌入，其方法仍需显式调用并传递上下文
    Name string
}

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

// hello 方法实现 MyInterface 接口
func (o *Object) hello() string {
    // 如果 Object 不想自定义 hello 行为，它可以调用 DefaultHelloProvider 的方法
    // 并将自身（实现了 Namer 接口）传递过去
    provider := &DefaultHelloProvider{} // 实例化一个提供者
    return provider.GetDefaultHello(o)
}

// CustomObject 是另一个宿主类型，它选择覆盖 hello() 方法
type CustomObject struct {
    *DefaultHelloProvider // 嵌入提供者，但其方法不会自动感知宿主
    Name string
}

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

// hello 方法实现 MyInterface 接口，并提供自定义实现
func (co *CustomObject) hello() string {
    return fmt.Sprintf("Custom hello from %s!", co.Name)
}

func main() {
    obj := &Object{Name: "Go Object"}
    fmt.Println(obj.hello()) // 调用 Object 的 hello()，它内部调用 DefaultHelloProvider

    customObj := &CustomObject{
        DefaultHelloProvider: &DefaultHelloProvider{},
        Name:                 "Custom Go Object",
    }
    fmt.Println(customObj.hello()) // 调用 CustomObject 的自定义 hello()

    // 演示多态性
    var i MyInterface
    i = obj
    fmt.Println("Interface call (Object):", i.hello())
    i = customObj
    fmt.Println("Interface call (CustomObject):", i.hello())
}