iOS 组合模式

组合模式: 将对象组合成树形结构以表示‘部分-整体’的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

在数据结构里面，树结构是很重要，我们可以把树的结构应用到设计模式里面。

例子1：iOS中的UIView的无线组合, layer的无限组合

例子2：文件和文件夹目录

组合模式结构图：

        

 典型的C o m p o s i t e对象结构如下图所示:

构建模式的组成

抽象构件角色（component）：是组合中的对象声明接口，在适当的情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件。
这个接口可  以用来管理所有的子对象。(可选)在递归结构中定义一个接口，用于访问一个父部件，并在合适的情况下实现它。  

树叶构件角色(Leaf)：在组合树中表示叶节点对象，叶节点没有子节点。并在组合中定义图元对象的行为。

树枝构件角色（Composite）：定义有子部件的那些部件的行为。存储子部件。在Component接口中实现与子部件有关的操作。

客户角色（Client）：通过component接口操纵组合部件的对象。

那么组合模式的实例如下：

//抽象的部件类描述将来所有部件共有的行为
public abstract class Component
{
    protected string name;
    public string Name
    {
        get
        {
            return name;
        }
        set
        {
            name = value;
        }
    }
    //添加部件
    public abstract void Add(Component component);
    //删除部件
    public abstract void Remove(Component component);
    //遍历所有子部件
    public abstract void eachChild();
}

//组合部件类
public class Leaf : Component
{
    //叶子节点不具备添加的能力，所以不实现
    public override void Add(Component component)
    {
        throw new NotImplementedException();
    }

    //叶子节点不具备添加的能力必然也不能删除
    public override void Remove(Component component)
    {
        throw new NotImplementedException();
    }

    //叶子节点没有子节点所以显示自己的执行结果
    public override void eachChild()
    {
        Console.WriteLine("{0}执行了..",name);
    }
}

//组合类
public class Composite : Component
{
    //用来保存组合的部件
    List<Component> myList = new List<Component>();

    //添加节点 添加部件
    public override void Add(Component component)
    {
        myList.Add(component);
    }

    //删除节点 删除部件
    public override void Remove(Component component)
    {
        myList.Remove(component);
    }

    //遍历子节点
    public override void eachChild()
    {
        Console.WriteLine("{0}执行了..", name);
        foreach (Component c in myList)
        {
            c.eachChild();
        }
    }
}
static void Main(string[] args)
{
    //构造根节点
    Composite rootComponent = new Composite();
    rootComponent.Name = "根节点";

    //添加两个叶子几点，也就是子部件
    Leaf l = new Leaf();
    l.Name = "叶子节点一";
    Leaf l1 = new Leaf();
    l1.Name = "叶子节点二";

    rootComponent.Add(l);
    rootComponent.Add(l1);

    //遍历组合部件
    rootComponent.eachChild();
 }

上面的是透明模式，叶子和树枝实现同样的方法。

下面的是安全模式，叶子不实现add和remove。在抽象类中不声明方法, 叶子也不实现, 只在Composite树枝类中实现add/remove

// 抽象构件类、节点类
abstract class Component {
	public String name;

	public Component(String name) {
		this.name = name;
	}

	// 公有操作
	public void getName() {
		System.out.println(this.name);
	}
}

// 树枝构件类
class Composite extends Component {

	private LinkedList<Component> children;

	public Composite(String name) {
		super(name);
		this.children = new LinkedList<Component>();
	}

	// 添加一个节点，可能是树枝、叶子
	public void add(Component child) {
		this.children.add(child);
	}

	// 删除一个节点，可能是树枝、叶子
	public void remove(String child) {
		this.children.remove(child);
	}

	// 获取子树
	public LinkedList<Component> getChildren() {
		return this.children;
	}
}


// 树叶构件类
class Leaf extends Component {

	public Leaf(String name) {
		super(name);
	}
}

什么情况下使用组合模式?

当发现需求中是体现部分与整体层次结构时，以及你希望用户可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象时，就应该考虑组合模式了。

组合模式优缺点

1) 简化客户端操作。客户端只需要面对一致的对象而不用考虑整体部分或者节点叶子的问题。

2) 具有较强的扩展性。当我们要更改组合对象时，我们只需要调整内部的层次关系，客户端不用做出任何改动.

3) 方便创建出复杂的层次结构。客户端不用理会组合里面的组成细节，容易添加节点或者叶子从而创建出复杂的树形结构

4) 需要遍历组织机构，或者处理的对象具有树形结构时, 非常适合使用组合模式.

要求较高的抽象性，如果节点和叶子有很多差异性的话，比如很多方法和属性都不一样，不适合使用组合模式