Golang中难以理解的OO模式问题求助

Golang中难以理解的OO模式问题求助 我拥有长期的Java开发经验，现在正转向Go语言。我曾尝试过Rust一段时间，但由于我的C和C++经验非常匮乏，我无法投入足够的时间和精力。Go是一个更合适的选择，特别是现在我可以使用fyne创建跨平台UI。我也一直在使用Flutter和Dart，并且非常喜欢它。言归正传，以下是我的问题。请参见下面的 我需要帮助的地方！。

我已将代码包含在下方。

我在结构体代码中有一个接口（称为NodeI）。它有三个方法。

• GetName() string
• GetNodeType() NodeType
• String() string

我有一个名为ParentNode的节点（我希望继承它的行为）。它有两个方法。

• GetName() string
• GetNodeType() NodeType

我有四个结构体，它们都有一个未命名的父节点。例如ListNode，并且它们都有一个String()函数（String() string）

type ListNode struct {
	parentNode     // 在所有四个结构体中
	value []*NodeI // ListNode特有
}

我使用指针来防止“复制”行为，并且所有结构体都必须是可更新的（除了父节点中的name和NodeType。这些是不可变的）

我正在构建一个树形结构，其中ListNode包含叶子节点以及更多的ListNode…等等。

我需要帮助的地方！

在函数中创建具体对象并将其作为接口返回 参考main.go中的makeStruct()函数。我更希望返回 *structure.NodeI。类似于一个工厂方法。然而，我无法将 *structure.ListNode 转换为 *structure.NodeI 并返回它。

我尝试了 pp := (*p).(*structure.NodeI)，其中p是 *structure.ListNode，并且我尝试了“许多”不同的格式来使转换生效，但都没有成功。

将具体对象作为其接口传递给方法 参考接受 *structure.NodeI 作为参数的printName函数。 我可以传递一个 *structure.NodeI 给它，但不能传递任何实现了该接口的具体对象。

例如，当p是 *structure.ListNode时，printName§ 会失败。而printName(b)可以工作。这里的b是(T) *structure.NodeI。它是由ListNode的GetNodeAt(i)方法返回的，并且是作为structure.NumberNode创建的。

请帮助我。如果这些模式能够应用，代码将更容易阅读和理解。

非常感谢

Stuart

main.go

func main() {
	p := makeStruct()
	fmt.Printf(" 1: %T\n", p) // *structure.ListNode
	fmt.Printf(" 2: %s", p)   // ListNode的String()
	b := p.GetValueAt(1)
	//
	//	printName(p) // 这无法编译。p是 *structure.NumberNode
	//
	printName(b, " 3")
	fmt.Printf(" 4: %T\n", b)  // *structure.NodeI
	fmt.Printf(" 5: %T\n", *b) // *structure.NumberNode
	fmt.Printf(" 6: %s\n", *b) // NumberNode的String()

	bb := (*b).(*structure.NumberNode)
	fmt.Printf(" 7: %T\n", bb) // *structure.NumberNode

	bb.SetValue(999)
	fmt.Printf(" 8: %s\n", bb.GetName())  // NUM
	fmt.Printf(" 9: %f\n", bb.GetValue()) // 999.000000
	fmt.Printf("10: %s\n", bb)            // NumberNode的String()

	fmt.Printf("11: %s", p) // ListNode的String()
}

func printName(ni *structure.NodeI, id string) {
	fmt.Printf("%s: Name: %s\n", id, (*ni).GetName())
}

func makeStruct() *structure.ListNode {
	p := structure.NewListNode()
	s := structure.NewStringNode("STR", "B")
	n := structure.NewNumberNode("NUM", 123.5)
	b := structure.NewBoolNode("BOO", true)
	p.AddValue(s)
	p.AddValue(n)
	p.AddValue(b)
	fmt.Printf(" 0: %T\n", p) // *structure.ListNode
	// pp := (*p).(*structure.NodeI)
	// fmt.Printf("makeStruct: %T", pp) // *structure.ListNode
	return p
}

节点代码！

package structure

import (
	"fmt"
	"strings"
)

type NodeType int

const (
	NT_NUMBER NodeType = iota
	NT_STRING NodeType = iota
	NT_BOOL   NodeType = iota
)

type NodeI interface {
	GetName() string
	GetNodeType() NodeType
	String() string
}

//
// 父节点接口 (NodeI) 和属性
//
type parentNode struct {
	name string
	nt   NodeType
}

func newParentNode(name string, nt NodeType) parentNode {
	return parentNode{name: name, nt: nt}
}
func (n *parentNode) GetName() string {
	return n.name
}
func (n *parentNode) GetNodeType() NodeType {
	return n.nt
}

type ListNode struct {
	parentNode
	value []*NodeI
}

//
// 列表节点是一个ParentNode，其值类型为 []NodeI
//
func NewListNode() *ListNode {
	return &ListNode{parentNode: newParentNode("", NT_NUMBER), value: make([]*NodeI, 0)}
}
func (n *ListNode) GetValue() *[]*NodeI {
	return &n.value
}
func (n *ListNode) GetValueAt(i int) *NodeI {
	return n.value[i]
}
func (n *ListNode) AddValue(node NodeI) {
	n.value = append(n.value, &node)
}

func (n *ListNode) String() string {
	var sb strings.Builder
	sb.WriteString("ListNode.String() :\n")
	for i, v := range n.value {
		sb.WriteString(fmt.Sprintf("   %d :", i))
		sb.WriteString((*v).String())
		sb.WriteString("\n")
	}
	return sb.String()
}

//
// 字符串节点是一个ParentNode，其值类型为 string
//
type StringNode struct {
	parentNode
	value string
}

func NewStringNode(name string, value string) *StringNode {
	return &StringNode{parentNode: newParentNode(name, NT_STRING), value: value}
}
func (n *StringNode) GetValue() string {
	return n.value
}
func (n *StringNode) SetValue(newValue string) {
	n.value = newValue
}
func (n *StringNode) String() string {
	return fmt.Sprintf("StringNode.String(): \"%s\": \"%s\"", n.GetName(), n.value)
}

//
// 数字节点是一个ParentNode，其值类型为 float64
//
type NumberNode struct {
	parentNode
	value float64
}

func NewNumberNode(name string, value float64) *NumberNode {
	return &NumberNode{parentNode: newParentNode(name, NT_NUMBER), value: value}
}
func (n *NumberNode) GetValue() float64 {
	return n.value
}
func (n *NumberNode) SetValue(newValue float64) {
	n.value = newValue
}
func (n *NumberNode) String() string {
	return fmt.Sprintf("NumberNode.String(): \"%s\": %f", n.GetName(), n.value)
}

//
// 布尔节点是一个ParentNode，其值类型为 bool
//
type BoolNode struct {
	parentNode
	value bool
}

func NewBoolNode(name string, value bool) *BoolNode {
	return &BoolNode{parentNode: newParentNode(name, NT_BOOL), value: value}
}
func (n *BoolNode) GetValue() bool {
	return n.value
}
func (n *BoolNode) SetValue(newValue bool) {
	n.value = newValue
}
func (n *BoolNode) String() string {
	return fmt.Sprintf("BoolNode.String(): \"%s\": %t", n.GetName(), n.value)
}