Go中组合模式通过接口统一Leaf与Composite行为，Component接口强制实现Add/Remove/Operation等方法，Composite用[]Component切片和指针接收者管理子节点，Leaf仅实现方法而不持子节点，体现“容器即组件”的抽象本质。
Go 语言没有继承，但组合模式完全可行——关键不是“怎么模拟类继承”，而是“如何用接口 + 嵌入 + 多态表达树形容器关系”。
用 Component 接口统一叶子与容器行为
组合模式的核心是让客户端无需区分单个对象（Leaf）和复合对象（Composite）。在 Go 中，这靠接口实现，而不是基类。定义一个 Component 接口，暴露所有需要被统一调用的方法，比如 Add、Remove、Operation：
type Component interface {
Operation() string
Add(c Component)
Remove(c Component)
GetChild(index int) Component
}
注意：Add 和 Remove 对叶子节点无意义，但接口必须提供——这是组合模式的契约。叶子实现时可 panic 或静默忽略，但不能缺失方法签名。
- 强制统一调用入口，避免客户端反复类型断言
- 接口不包含字段，只约束行为，符合 Go 的“小接口”哲学
- 如果某些叶子确实需要支持动态添加（如可扩展配置项），它自然就变成 Composite，无需重构接口
用结构体嵌入 + 指针接收者实现 Composite
Composite 是真正持有子节点的容器，它必须能增删查子节点。推荐用切片保存 Component 接口值，并用指针接收者实现方法，确保修改生效：
立即学习“go语言免费学习笔记（深入）”；
type Composite struct {
children []Component
}
func (c *Composite) Add(child Component) {
c.children = append(c.children, child)
}
func (c *Composite) Remove(child Component) {
for i, ch := range c.children {
if ch == child {
c.children = append(c.children[:i], c.children[i+1:]...)
return
}
}
}
func (c *Composite) GetChild(index int) Component {
if index < 0 || index >= len(c.children) {
return nil
}
return c.children[index]
}
func (c *Composite) Operation() string {
var res string
for _, child := range c.children {
res += child.Operation()
}
return "Composite: " + res
}
关键点：
- 字段
children类型是[]Component，不是具体结构体切片，否则无法存Leaf - 所有方法都用
*Composite接收者，否则Add修改的是副本，子节点加不进去 -
GetChild返回Component，保持多态链完整；若返回具体类型，下游又得断言
叶子节点只需实现接口，不嵌入任何东西
Leaf 是终端节点，不持有子节点，因此不需要切片或嵌入逻辑。它的实现极简：
type Leaf struct {
name string
}
func (l *Leaf) Operation() string {
return "Leaf(" + l.name + ")"
}
func (l *Leaf) Add(c Component) {
// 可选：panic("Leaf does not support Add") 或直接 return
}
func (l *Leaf) Remove(c Component) {}
func (l *Leaf) GetChild(index int) Component {
return nil
}
常见误区：
- 给
Leaf加children []Component字段——冗余且误导，破坏语义清晰性 - 用值接收者实现
Operation——没问题；但若后续要支持修改内部状态（如计数器），就得改用指针 - 在
Add/Remove里 panic ——生产环境建议日志记录 + 静默忽略，除非明确要求强契约校验
构建树时注意接口值的生命周期和 nil 安全
实际使用中，树的构建常涉及临时变量或局部作用域。例如：
root := &Composite{}
root.Add(&Leaf{name: "A"})
root.Add(&Composite{
children: []Component{&Leaf{name: "B1"}, &Leaf{name: "B2"}},
})
fmt.Println(root.Operation()) // 输出正常
这里容易出问题的地方：
- 传入
&Leaf{...}而非Leaf{...}：因为Component接口方法是用指针接收者定义的，值类型无法满足接口（方法集不匹配） -
GetChild(i)返回nil时，调用.Operation()会 panic ——务必在调用前判空，或由上层保证索引合法 - 如果子节点是闭包捕获的局部变量，需确认其逃逸分析结果；不过一般树结构对象生命周期较长，建议显式分配（
new(Leaf)或&Leaf{}）
组合模式在 Go 里不是语法糖，而是对“容器即组件”这一抽象的诚实表达。最易被忽略的其实是接口方法的完整性设计：一旦加了 Add，所有实现都得面对它——哪怕只是空实现。这不是缺陷，是契约的重量。
