结构型模式--组合模式

1、概念

组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。
这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式。
意图：将对象组合成树形结构以表示"部分-整体"的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
主要解决：它在我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以像处理简单元素一样来处理复杂元素，从而使得客户程序与复杂元素的内部结构解耦。
何时使用： 1、您想表示对象的部分-整体层次结构（树形结构）。 2、您希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。
如何解决：树枝和叶子实现统一接口，树枝内部组合该接口。
关键代码：树枝内部组合该接口，并且含有内部属性 List，里面放 Component。
应用实例： 1、算术表达式包括操作数、操作符和另一个操作数，其中，另一个操作符也可以是操作数、操作符和另一个操作数。 2、在 JAVA AWT 和 SWING 中，对于 Button 和 Checkbox 是树叶，Container 是树枝。
优点： 1、高层模块调用简单。 2、节点自由增加。
缺点：在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则。
使用场景：部分、整体场景，如树形菜单，文件、文件夹的管理。
注意事项：定义时为具体类。

2、例子

	首先，一张卡可以在总部，分店，加盟店使用，那么总部可以刷卡，分店也可以刷卡，加盟店也可以刷卡，这个属性结构的店面层级关系就明确啦。
	那么，总店刷卡消费与分店刷卡消费是一样的道理，那么总店与分店对会员卡的使用也具有一致性。

3、实践

Composite.go

package CompositePattern

type Composite interface {
	GetNode()Composite
	SetNode(node Composite)
	GetName()string
	SetName(name string)
	AddChild(child Composite)
	Print(pre string)
}
type Common struct{
	Node Composite
	Name   string
}

const (
	Node = iota
	Leaf
)

func NewCommonNode(kind int, name string)Composite{
	var common Composite
	switch kind {
	case Node:
		common = NewCombinateNode()
	case Leaf:
		common = NewLeafNode()
	}
	common.SetName(name)
	return common
}

func (c* Common)GetNode()Composite{
	return c.Node
}

func (c* Common)SetNode(node Composite){
	c.Node = node
}

func (c* Common)GetName()string{
	return c.Name
}

func (c* Common)SetName(name string){
	c.Name = name
}

func (c* Common)AddChild(child Composite){

}

func (c* Common)Print(pre string){

}

CombinateNode.go

package CompositePattern

import "fmt"

type CombinateNode struct{
	Common
	Childs []Composite  //叶子节点
}

func NewCombinateNode()*CombinateNode{
	return &CombinateNode{Childs: make([]Composite,0)}
}

// 重写 AddChild
func (c* CombinateNode)AddChild(child Composite){
	child.SetNode(child)
	c.Childs = append(c.Childs, child)
}

// 重写 Print
func (c* CombinateNode)Print(pre string){
	fmt.Println(pre,c.Name)
	pre += "   "
	for _,item := range c.Childs{
		item.Print(pre)
	}
}

LeafNode.go

package CompositePattern

import "fmt"

type LeafNode struct{
	Common
}

func NewLeafNode()*LeafNode{
	return &LeafNode{}
}

// 重写print
func (l* LeafNode)Print(pre string){
	fmt.Println(pre,l.Name)
}

main.go

package main

import "DesignPattern/CompositePattern"

func main(){
	root := CompositePattern.NewCommonNode(CompositePattern.Node,"root")
	r1 := CompositePattern.NewCommonNode(CompositePattern.Node,"r1")
	r2 := CompositePattern.NewCommonNode(CompositePattern.Node,"r2")
	r3 := CompositePattern.NewCommonNode(CompositePattern.Node,"r3")

	l1 := CompositePattern.NewCommonNode(CompositePattern.Leaf,"l1")
	l2 := CompositePattern.NewCommonNode(CompositePattern.Leaf,"l2")
	l3 := CompositePattern.NewCommonNode(CompositePattern.Leaf,"l3")

	root.AddChild(r1)
	root.AddChild(r2)
	root.AddChild(r3)
	r1.AddChild(l1)
	r2.AddChild(l2)
	r3.AddChild(l3)
	root.Print("")
}