Go语言中接口方法的通用实现模式：解决嵌入类型方法访问派生类型问题

type Node interface {
    fmt.Stringer
    Print(NodePrinter)
}

type NodeBase struct{}

// 期望：NodeBase的String方法能调用到嵌入它的具体类型的Print方法
func (NodeBase) String() string {
    np := NewNodePrinter()
    // 问题：这里无法直接调用到“派生类型”的Print方法
    // 因为接收者是NodeBase，它不具备Print方法，也无法知道具体的外部类型
    // somehow call derived type passing the NodePrinter
    return np.Contents()
}

type NodeChild struct {
    NodeBase // 嵌入NodeBase
    // other stuff
}

func (NodeChild) Print(np NodePrinter) {
    // code that prints self to node printer
    np.AddContent("NodeChild specific content")
}

// nodeString 是一个辅助函数，用于为任何Node类型生成字符串表示
func nodeString(n Node) string {
    np := NewNodePrinter() // 创建一个新的NodePrinter
    n.Print(np)            // 调用Node接口的Print方法，实现多态
    return np.Contents()   // 返回NodePrinter中收集的内容
}

// 现在，你可以为任何Node类型添加String方法，只需一行代码
func (n NodeChild) String() string {
    return nodeString(n) // 将自身（NodeChild）作为Node接口传递给辅助函数
}

package main

import (
    "fmt"
    "strings"
)

// NodePrinter 接口定义了打印节点内容的方法
type NodePrinter interface {
    AddContent(s string)
    Contents() string
}

// SimpleNodePrinter 是NodePrinter的一个简单实现
type SimpleNodePrinter struct {
    builder strings.Builder
}

// NewNodePrinter 创建并返回一个新的SimpleNodePrinter实例
func NewNodePrinter() *SimpleNodePrinter {
    return &SimpleNodePrinter{}
}

// AddContent 将内容添加到打印器
func (snp *SimpleNodePrinter) AddContent(s string) {
    snp.builder.WriteString(s)
}

// Contents 返回打印器中所有内容的字符串表示
func (snp *SimpleNodePrinter) Contents() string {
    return snp.builder.String()
}

// Node 接口定义了所有节点类型必须实现的方法
type Node interface {
    fmt.Stringer // 继承fmt.Stringer接口
    Print(NodePrinter) // 定义节点特有的打印方法
}

// nodeString 是一个辅助函数，用于为任何Node类型生成字符串表示
// 它接收一个Node接口，并利用其Print方法来收集内容
func nodeString(n Node) string {
    np := NewNodePrinter() // 创建一个新的NodePrinter
    n.Print(np)            // 通过接口调用具体类型的Print方法
    return np.Contents()   // 返回NodePrinter中收集的内容
}

// NodeBase 结构体，作为基础类型，但其String方法不再直接实现
// 它的存在更多是为了演示原始问题中的意图，在实际解决方案中可省略或简化
type NodeBase struct{}

// NodeChild 是一个具体的节点类型，它嵌入了NodeBase
type NodeChild struct {
    NodeBase
    Name string
    Value int
}

// Print 实现了NodeChild类型特有的打印逻辑
func (nc NodeChild) Print(np NodePrinter) {
    np.AddContent(fmt.Sprintf("NodeChild{Name: %s, Value: %d}", nc.Name, nc.Value))
}

// String 实现了fmt.Stringer接口，它通过调用nodeString辅助函数来完成
func (nc NodeChild) String() string {
    return nodeString(nc) // 将自身（NodeChild）作为Node接口传递给辅助函数
}

// NodeLeaf 是另一个具体的节点类型
type NodeLeaf struct {
    NodeBase
    Label string
}

// Print 实现了NodeLeaf类型特有的打印逻辑
func (nl NodeLeaf) Print(np NodePrinter) {
    np.AddContent(fmt.Sprintf("NodeLeaf{Label: %s}", nl.Label))
}

// String 实现了fmt.Stringer接口，同样通过调用nodeString辅助函数
func (nl NodeLeaf) String() string {
    return nodeString(nl)
}

func main() {
    childNode := NodeChild{Name: "Root", Value: 123}
    leafNode := NodeLeaf{Label: "End"}

    // 直接使用fmt.Println，它会调用String()方法
    fmt.Println("Child Node:", childNode)
    fmt.Println("Leaf Node:", leafNode)

    // 也可以将它们作为Node接口类型处理
    var node1 Node = childNode
    var node2 Node = leafNode

    fmt.Println("Interface Node 1:", node1)
    fmt.Println("Interface Node 2:", node2)
}

Child Node: NodeChild{Name: Root, Value: 123}
Leaf Node: NodeLeaf{Label: End}
Interface Node 1: NodeChild{Name: Root, Value: 123}
Interface Node 2: NodeLeaf{Label: End}