设计模式之组合模式

概述

组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。
这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式。
目的：
将对象组合成树形结构以表示部分整体的关系，组合模式使得用户对单个对象和组合对象的使用具有一致性。

设计模式思想

组合模式中的角色

• 抽象构件角色（component）：是组合中的对象声明接口，在适当的情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件。这个接口可以用来管理所有的子对象。
• 树叶构件角色(Leaf)：在组合树中表示叶节点对象，叶节点没有子节点。并在组合中定义图元对象的行为。
• 树枝构件角色（Composite）：定义有子部件的那些部件的行为。存储子部件。在Component接口中实现与子部件有关的操作。
• 客户角色（Client）：通过component接口操纵组合部件的对象。

透明方式与安全方式

透明方式：在Component中声明所有来管理子对象的方法，其中包括Add，Remove等。这样实现Component接口的所有子类都具备了Add和Remove方法。这样做的好处是叶节点和枝节点对于外界没有区别，它们具备完全一致的接口。

安全方式：在Component中不去声明Add和Remove方法，那么子类的Leaf就不需要实现它，而是在Composit声明所有用来管理子类对象的方法。

两种方式有缺点：对于透明方式，客户端对叶节点和枝节点是一致的，但叶节点并不具备Add和Remove的功能，因而对它们的实现是没有意义的；对于安全方式，叶节点无需在实现Add与Remove这样的方法，但是对于客户端来说，必须对叶节点和枝节点进行判定，为客户端的使用带来不便。

设计模式源码

本源码采用安全方式，以公司与公司的关系，从代码角度来阐述组合模式。
代码结构图

抽象构件角色（component）

/** * 公司类，抽象类和接口 * @author Administrator * */public abstract class Company {    public String name;    public Company(String name) {        this.name = name;    }    public abstract void Add(Company company);//增加    public abstract void Remove(Company company);//删除    public abstract void Display(int depth);//显示    public abstract void LineOfDuty();//履行职责}

抽象构件角色（component）具体实现类

/** * 具体公司实现类，实现接口，树枝节点 * @author Administrator * */public class ConcreteCompany extends Company{private List<Company> childrenCompany;//private String name;    public ConcreteCompany(String name) {        super(name);        this.name=name;        childrenCompany=new ArrayList<Company>();    }    @Override    public void Add(Company company) {        childrenCompany.add(company);    }    @Override    public void Remove(Company company) {    childrenCompany.remove(company);    }    @Override    public void Display(int depth) {        // TODO Auto-generated method stub        System.out.println(new String("-"+depth)+name);        for (Company company : childrenCompany) {            company.Display(depth+2);        }    }    @Override    public void LineOfDuty() {        for (Company company : childrenCompany) {            company.LineOfDuty();        }    }}

package com.designpattern.compositePatterns;/** * 人力资源部类，树叶节点，无子节点 * @author Administrator * */public class HRDepartment extends Company{//  private String name;    public HRDepartment(String name) {        super(name);        this.name=name;    }    @Override    public void Add(Company company) {        // TODO Auto-generated method stub    }    @Override    public void Remove(Company company) {        // TODO Auto-generated method stub    }    @Override    public void Display(int depth) {        // TODO Auto-generated method stub        System.out.println(name);    }    @Override    public void LineOfDuty() {        // TODO Auto-generated method stub        System.out.println(name+":员工招聘培训管理");    }}

package com.designpattern.compositePatterns;/** * 财务部类，树叶节点，无子节点 * @author Administrator * */public class FinanceDepartment extends Company{    public FinanceDepartment(String name) {        super(name);        this.name=name;    }    @Override    public void Add(Company company) {        // TODO Auto-generated method stub    }    @Override    public void Remove(Company company) {        // TODO Auto-generated method stub    }    @Override    public void Display(int depth) {        // TODO Auto-generated method stub        System.out.println(name);    }    @Override    public void LineOfDuty() {        // TODO Auto-generated method stub        System.out.println(name+":公司财务收支管理");    }}

package com.designpattern.test;import com.designpattern.compositePatterns.ConcreteCompany;import com.designpattern.compositePatterns.FinanceDepartment;import com.designpattern.compositePatterns.HRDepartment;public class TestComposite {    public static void main(String[] args) {        ConcreteCompany root = new ConcreteCompany("河南总公司");        root.Add(new HRDepartment("河南总公司人力资源部"));        root.Add(new FinanceDepartment("河南总公司财务部"));        ConcreteCompany comp = new ConcreteCompany("北京华北分公司");        root.Add(new HRDepartment("华北分公司人力资源部"));        root.Add(new FinanceDepartment("华北分公司财务部"));        root.Add(comp);        ConcreteCompany comp1 = new ConcreteCompany("天津分公司");        root.Add(new HRDepartment("天津分公司人力资源部"));        root.Add(new FinanceDepartment("天津分公司财务部"));        comp.Add(comp1);        ConcreteCompany comp2 = new ConcreteCompany("雄安分公司");        root.Add(new HRDepartment("雄安分公司人力资源部"));        root.Add(new FinanceDepartment("雄安分公司财务部"));        comp.Add(comp2);        System.out.println("公司结构图：");        root.Display(1);        System.out.println("部门职责：");        root.LineOfDuty();    }}

测试效果：

公司结构图：-1河南总公司总公司人力资源部总公司财务部华北分公司人力资源部华北分公司财务部-3北京华北分公司-5天津分公司-5雄安分公司天津分公司人力资源部天津分公司财务部雄安分公司人力资源部雄安分公司财务部部门职责：总公司人力资源部:员工招聘培训管理总公司财务部:公司财务收支管理华北分公司人力资源部:员工招聘培训管理华北分公司财务部:公司财务收支管理天津分公司人力资源部:员工招聘培训管理天津分公司财务部:公司财务收支管理雄安分公司人力资源部:员工招聘培训管理雄安分公司财务部:公司财务收支管理

优缺点及使用场景

优点：
1、使客户端调用简单，它可以一致使用组合结构或是其中单个对象，简化了客户端代码。
2、容易在组合体内增加对象部件。客户端不必因加入了新的部件而更改代码。有利于功能的扩展。

缺点：

1. 在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则。
2. 需要抉择使用透明方式还是安全方式。
3. 透明方式违背了面向对象的单一职责原则；安全方式增加了客户需要端判定的负担。

使用场景：

1. 部分、整体场景，如树形菜单，文件、文件夹的管理。
2. 当想表达对象的部分-整体的层次结构时。
3. 希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象时。

总结

组合模式解耦了客户程序与复杂元素内部结构，从而使客户程序可以向处理简单元素一样来处理复杂元素。但是在使用时需要抉择使用透明方式还是安全方式，无意增加了客户端负担。透明方式和安全方式各有优劣，使用时谨慎选择！