设计模式（十）组合(结构型)

概述                                                                            

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

例子1：就是多级树形菜单。

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

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

有时候又叫做部分-整体模式，它使我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以向处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。

组合模式让你可以优化处理递归或分级数据结构。有许多关于分级数据结构的例子，使得组合模式非常有用武之地。关于分级数据结构的一个普遍性的例子是你每次使 用电脑时所遇到的:文件系统。文件系统由目录和文件组成。每个目录都可以装内容。目录的内容可以是文件，也可以是目录。按照这种方式，计算机的文件系统就 是以递归结构来组织的。如果你想要描述这样的数据结构，那么你可以使用组合模式

分类                                                                            

1. 将管理子元素的方法定义在Composite类中
2. 将管理子元素的方法定义在Component接口中，这样Leaf类就需要对这些方法空实现。

适用                                                                           

1. 你想表示对象的部分-整体层次结构
2. 你希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。

 类图                                                                           

 

角色                                                                           

抽象构件角色（component）：是组合中的对象声明接口，在适当的情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件。

这个接口可  以用来管理所有的子对象。(可选)在递归结构中定义一个接口，用于访问一个父部件，并在合适的情况下实现它。  

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

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

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

代码                                                                            

Company.java

package com.yydcdut;

public interface Company {
    public String getInfo();
}

树枝节点ConcreteCompany

package com.yydcdut;

import java.util.ArrayList;

public class ConcreteCompany implements Company {

    private ArrayList<Company> companyList = new ArrayList<Company>();
    private String name;
    private String position;
    private int salary;

    public ConcreteCompany(String name, String position, int salary) {
        super();
        this.name = name;
        this.position = position;
        this.salary = salary;
    }

    @Override
    public String getInfo() {
        String info = "";
        info = "名称：" + name + "\t职位" + position + "\t薪水" + salary;
        return info;
    }

    public void add(Company company) {
        companyList.add(company);
    }

    public void remove(Company company) {
        companyList.remove(company);
    }

    public ArrayList<Company> getChild() {
        return companyList;
    }

}

叶子节点Eployee

package com.yydcdut;

public class Employee implements Company {

    private String name;
    private String position;
    private int salary;

    public Employee(String name, String position, int salary) {
        super();
        this.name = name;
        this.position = position;
        this.salary = salary;
    }

    @Override
    public String getInfo() {
        String info = "";
        info = "名称：" + name + "\t职位" + position + "\t薪水" + salary;
        return info;
    }

}

 测试：

package com.yydcdut;

public class Main {

    public static void main(String[] args) {
        //BOSS
        ConcreteCompany root = new ConcreteCompany("zhangsan","ceo",10000);
        //Manager
        ConcreteCompany developDep = new ConcreteCompany("sisi", "yanha", 8000);
        ConcreteCompany salesDep = new ConcreteCompany("wangwu", "xiaoshou", 8000);
        ConcreteCompany financeDep = new ConcreteCompany("maliu", "caiwu", 8000);
        //employee
        Employee e1 = new Employee("A", "yanfa", 3000);
        Employee e2 = new Employee("B", "yanfa", 4000);
        Employee e3 = new Employee("C", "yanfa", 5000);
        Employee e4 = new Employee("D", "yanfa", 6000);
        Employee e5 = new Employee("E", "xiaoshou", 3000);
        Employee e6 = new Employee("F", "xiaoshou", 4000);
        Employee e7 = new Employee("G", "xiaoshou", 5000);
        Employee e8 = new Employee("H", "xiaoshou", 3000);
        Employee e9 = new Employee("I", "caiwu", 3000);
        //tree
        root.add(developDep);
        root.add(salesDep);
        root.add(financeDep);
        developDep.add(e1);
        developDep.add(e2);
        developDep.add(e3);
        developDep.add(e4);
        salesDep.add(e5);
        salesDep.add(e6);
        salesDep.add(e7);
        salesDep.add(e8);
        financeDep.add(e9);
        System.out.println(root.getInfo());
        display(root);
    }
    
    public static void display(ConcreteCompany root)
    {
        for(Company c : root.getChild())
        {
            if(c instanceof Employee) 
            {
                System.out.println(c.getInfo());
            }
            else
            {
                System.out.println("\n"+c.getInfo());
                display((ConcreteCompany) c);
            }
        }
    }

}

结果：

名称：zhangsan    职位ceo    薪水10000

名称：sisi    职位yanha    薪水8000
名称：A    职位yanfa    薪水3000
名称：B    职位yanfa    薪水4000
名称：C    职位yanfa    薪水5000
名称：D    职位yanfa    薪水6000

名称：wangwu    职位xiaoshou    薪水8000
名称：E    职位xiaoshou    薪水3000
名称：F    职位xiaoshou    薪水4000
名称：G    职位xiaoshou    薪水5000
名称：H    职位xiaoshou    薪水3000

名称：maliu    职位caiwu    薪水8000
名称：I    职位caiwu    薪水3000

组合模式和其他相关模式                                             

1. 装饰模式（Decorator模式）经常与Composite模式一起使用。当装饰和组合一起使用时，它们通常有一个公共的父类。因此装饰必须支持具有 Add、Remove和GetChild 操作的Component接口。
2. Flyweight模式让你共享组件，但不再能引用他们的父部件。
3. （迭代器模式）Itertor可用来遍历Composite。
4. （观察者模式）Visitor将本来应该分布在Composite和Leaf类中的操作和行为局部化。

总结                                                                             

组合模式解耦了客户程序与复杂元素内部结构，从而使客户程序可以向处理简单元素一样来处理复杂元素。

如果你想要创建层次结构，并可以在其中以相同的方式对待所有元素，那么组合模式就是最理想的选择。

我是天王盖地虎的分割线                                            

源代码：http://pan.baidu.com/s/1dD1Qx01

java组合.zip