组合模式--分公司=一部门

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

 　为什么Leaf类中也有add和remove，树叶不是不可以再长分支吗？
        是的，这种方式叫做透明方式，也就是说在Component中声明所有用来管理子对象的方法啊，其中包括add、remove等。这样实现Component接口的所有子类都具备了add和remove。这样做的好处就是叶节点和枝节点对于外界没有区别，他们具备完全一致的行为接口。但问题也很明显，因为Leaf类本身不具备add()、remve()方法的功能，所以实现它是没有意义的。
        如果我不希望Leaf类中用add和remove方法，那么子类的Leaf也就不需要去实现它，而是在Composite声明所有用来管理子类对象的方法，这样做就不会出现刚才提到的问题，不过由于不够透明，所以树叶和树枝将不具有相同的接口，客户端的调用需要做相应的判断，带来了不便。
        
　 透明方式，那样就不用做任何判断了。

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

/**
 * Component为组合中的对象声明接口，在适当情况下，实现所有类共有接口的默认行为。
 *     声明一个接口用于访问和管理Component的子部件
 * @author 贤元
 *
 */
public abstract class Component {
    protected String name;
    public Component(String name){
        this.name = name;
    }
    
    public abstract void add(Component c);
    public abstract void remove(Component c);
    public abstract void display(int depth);
}

/**
 * Component定义有枝节点行为，用来存储子部件，
 *     在Component接口中实现与子部件有关的操作，比如增加add和删除remove
 * @author 贤元
 *
 */
public class Composite extends Component {
    
    private List<Component> children = new LinkedList<Component>();
    
    public Composite(String name) {
        super(name);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void add(Component c) {
        children.add(c);
    }

    @Override
    public void remove(Component c) {
        children.remove(c);
    }

    @Override
    public void display(int depth) {
        String str = "";//用于拼接'-',depth表示多少，就拼接多少个'-',用于显示效果
        for(int i=0;i<depth;i++){
            str += "-";
        }
        System.out.println(str+name);
        
        for(Component component:children){
            component.display((depth+2));
        }
    }

}

public class Leaf extends Component{
    
    public Leaf(String name) {
        super(name);
        // TODO Auto-generated constructor stub
    }

    /**
     * 由于叶子没有再增加分支和树叶，所以add和remove实现它没有意义，
     *     但这样做可以消除叶节点和枝节点对象在抽象层次的区别，他们具备完全一致的接口。
     */
    @Override
    public void add(Component c) {
        System.out.println("Cannot add to a leaf"); 
    }

    @Override
    public void remove(Component c) {
        System.out.println("Cannot remove from a leaf");
    }

    //叶节点的具体方法，此处是显示其名称和级别
    @Override
    public void display(int depth) {
        String str = "";////用于拼接'-',depth表示多少，就拼接多少个'-',用于显示效果
        for(int i=0;i<depth;i++){
            str += "-";
        }
        System.out.println(str+name);
    }
}

public class TestClient {
    public static void main(String[] args) {
        //生成树根root，根上长出两叶LeafA和LeafB
        Component root = new Composite("root");
        root.add(new Leaf("Leaf A"));
        root.add(new Leaf("Leaf B"));
        
        //根上长出分支CompositeX，分支上也有两叶LeafXA和LeafXB
        Composite comp = new Composite("Composite A");
        comp.add(new Leaf("Leaf XA"));
        comp.add(new Leaf("Leaf XB"));
        
        root.add(comp);
        
        //在CompositeX上再长出分支CompositeXY，分支上也有两叶LeafXYA和LeafXYB
        Composite comp2 = new Composite("Composite XY");
        comp2.add(new Leaf("Leaf XYA"));
        comp2.add(new Leaf("Leaf XYB"));
        
        comp.add(comp2);
        
        root.add(new Leaf("Leaf C"));
        
        //根部又长出两叶LeafC和LeafD,可惜LeafD没长牢，被风吹走了
        Leaf leaf = new Leaf("Leaf D");
        root.add(leaf);
        root.remove(leaf);
        
        //显示大树的样子
        root.display(1);
        
    }
}

打印结果：

-root
---Leaf A
---Leaf B
---Composite A
-----Leaf XA
-----Leaf XB
-----Composite XY
-------Leaf XYA
-------Leaf XYB
---Leaf C

UML图：

　　

 

一个例子：

　　组合模式定义了包含人力资源部和财务部这些基本对象和分公司、办事处等组合对象的类层次结构。基本对象可以被组合成更复杂的组合对象，而这个组合对象又可以被组合，这样不断地递归下去，客户代码中，任何用到基本对象的地方都可以使用组合对象了。用户不关心到底是处理一个叶节点还是处理一个组合组件，也就用不着为定义组合而写一些选择判断语句了。组合模式让客户可以一致地使用组合结构和单个对象。
    只要写一套代码，就可以在不同层次级别中使用，而不用对不同层次的再重复开发一套代码

　　

//公司类，抽象类或接口
public abstract class Company {
    protected String name;
    
    public Company(String name){
        this.name = name;
    }
    
    public abstract void add(Company c);//增加
    public abstract void remove(Company c);//移除
    public abstract void display(int depth);//显示
    public abstract void lineOfDuty();//履行职责
}

//具体公司类，实现接口，树枝节点
public class ConcreteCompany extends Company {

    private List<Company> children = new LinkedList<Company>();
    
    //构造方法
    public ConcreteCompany(String name) {
        super(name);
    }

    @Override
    public void add(Company c) {
        children.add(c);
    }

    @Override
    public void remove(Company c) {
        children.remove(c);
    }

    @Override
    public void display(int depth) {
        String str = "";//用于拼接'-',dept等于多少就表示拼接几个'-',用于显示效果
        for(int i=0;i<depth;i++){
            str +="-";
        }
        System.out.println(str+name);
        
        for(Company component:children){
            component.display(depth+2);//递归显示
        }
    }
    
    
    //履行职责
    @Override
    public void lineOfDuty() {
        // TODO Auto-generated method stub
        for(Company component:children){
            component.lineOfDuty();
        }
    }

}

//人力资源部
public class HRDepartment extends Company {

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

    @Override
    public void add(Company c) {
    }

    @Override
    public void remove(Company c) {
    }

    @Override
    public void display(int depth) {
        String str = "";// 用于拼接'-',dept等于多少就表示拼接几个'-',用于显示效果
        for (int i = 0; i < depth; i++) {
            str += "-";
        }
        System.out.println(str + name);
    }

    // 履行职责
    @Override
    public void lineOfDuty() {
        System.out.println(name + "员工招聘管理培训");
    }
}

//财务部
public class FinanceDepartment extends Company {

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

    @Override
    public void add(Company c) {
    }

    @Override
    public void remove(Company c) {
    }

    @Override
    public void display(int depth) {
        String str = "";//用于拼接'-',dept等于多少就表示拼接几个'-',用于显示效果
        for(int i=0;i<depth;i++){
            str +="-";
        }
        System.out.println(str+name);
    }

    @Override
    public void lineOfDuty() {
        System.out.println(name+"公司财务收支管理");
    }

}

//客户端
public class TestClient {
    public static void main(String[] args) {
        ConcreteCompany root = new ConcreteCompany("北京总公司");
        root.add(new HRDepartment("总公司人力资源部"));
        root.add(new FinanceDepartment("总公司财务部"));
        
        ConcreteCompany comp = new ConcreteCompany("华东分公司");
        comp.add(new HRDepartment("华东分公司人力资源部"));
        comp.add(new FinanceDepartment("华东分公司财务部"));
        root.add(comp);//将子公司添加到总公司
        
        ConcreteCompany comp1 = new ConcreteCompany("南京办事处");
        comp1.add(new HRDepartment("南京事处人力资源部"));
        comp1.add(new FinanceDepartment("南京办事处财务部"));
        root.add(comp1);//将子公司添加到总公司
        
        ConcreteCompany comp2 = new ConcreteCompany("杭州办事处");
        comp2.add(new HRDepartment("杭州办事处人力资源部"));
        comp2.add(new FinanceDepartment("杭州办事处财务部"));
        root.add(comp2);//将子公司添加到总公司
        
        System.out.println("结构图：");
        root.display(1);
        
        System.out.println("职责：");
        root.lineOfDuty();
        
    }
}

打印结果：

结构图：
-北京总公司
---总公司人力资源部
---总公司财务部
---华东分公司
-----华东分公司人力资源部
-----华东分公司财务部
---南京办事处
-----南京事处人力资源部
-----南京办事处财务部
---杭州办事处
-----杭州办事处人力资源部
-----杭州办事处财务部
职责：
总公司人力资源部员工招聘管理培训
总公司财务部公司财务收支管理
华东分公司人力资源部员工招聘管理培训
华东分公司财务部公司财务收支管理
南京事处人力资源部员工招聘管理培训
南京办事处财务部公司财务收支管理
杭州办事处人力资源部员工招聘管理培训
杭州办事处财务部公司财务收支管理

UML图：