4、常用设计模式之组合模式

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

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

/**
 * 组合中对象声明接口
 * Created by ZhuPengWei on 2018/1/29.
 */
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);
}

Leaf：在组合中表示叶节点对象，叶节点没有子节点。

/**
 * 叶节点对象
 * Created by ZhuPengWei on 2018/1/29.
 */
public class Leaf extends Component {

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


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

    @Override
    public void remove(Component c) {
        System.out.println("不能减少");
    }

    // 显示名称和级别
    @Override
    public void display(int depth) {
        System.out.println("name:" + name + ",depth:" + depth);
    }
}

Composite：定义有枝节点行为，用来存储子部件，在Conponent接口中实现与子部件有关的操作，比如add和remove

/**
 * 定义枝节点行为，用来存储子部件
 * Created by ZhuPengWei on 2018/1/29.
 */
public class Composite extends Component {

    // 存储下属的枝节点和叶节点
    private List<Component> children = new ArrayList<Component>();

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

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

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

    @Override
    public void display(int depth) {
        System.out.println("name:" + name + ",depth:" + depth);
        // 对下级进行遍历
        for (Component component : children) {
            component.display(depth + 2);
        }
    }
}

客户端代码：

/**
 * 客户端
 * Created by ZhuPengWei on 2018/1/29.
 */
public class Client {
    public static void main(String[] args) {

        // 生成树根root，根上长出两叶LeafA和LeafB
        Composite root = new Composite("root");
        root.add(new Leaf("LeafA"));
        root.add(new Leaf("LeafB"));

        // 根上长出分支CompositeX，分支上也有两叶子LeafXA和LeafXB
        Composite comp = new Composite("CompositeX");
        comp.add(new Leaf("LeafXA"));
        comp.add(new Leaf("LeafXB"));
        root.add(comp);

        // 在CompositeX上在长出分支CompositeXY，分支上也有LeafXYA和LeafXYB
        Composite comp2 = new Composite("CompositeXY");
        comp2.add(new Leaf("LeafXYA"));
        comp2.add(new Leaf("LeafXYB"));
        comp.add(comp2);

        // 根部上又长出LeafC和LeafD，可惜LeafD没有长牢，被风吹走了
        root.add(new Leaf("LeafC"));
        Leaf leafD = new Leaf("LeafD");
        root.add(leafD);
        root.remove(leafD);

        // 显示大树的样子
        root.display(1);
    }
}

输出结果

name:root,depth:1
name:LeafA,depth:3
name:LeafB,depth:3
name:CompositeX,depth:3
name:LeafXA,depth:5
name:LeafXB,depth:5
name:CompositeXY,depth:5
name:LeafXYA,depth:7
name:LeafXYB,depth:7
name:LeafC,depth:3

Process finished with exit code 0

透明方式与安全方式

树可能有无数的分枝，但只需反复用Composite就可以实现树状结构了，这种方式叫做透明方式。
如果说Leaf类当中不用add和remove方法，那么就需要安全方式。也就是在component接口中不去声明add和remove方法，那么子类的Leaf不需要去实现它，
而是在composite声明所有用来管理子类对象的方法，这样做不会出现刚才提到的问题，不过由于不够透明，所以树叶和树枝类将不具有相同的接口，客户端的
调用需要做相应的判断，带来了不便。

何时使用组合模式

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

实例—公司管理系统

代码结构图

公司类 抽象类或接口

/**
 * 公司类，抽象或者接口
 * Created by ZhuPengWei on 2018/1/29.
 */
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();
}

具体公司类 实现接口 树枝节点

/**
 * 具体公司类
 * Created by ZhuPengWei on 2018/1/29.
 */
public class ConcreteCompany extends Company {

    private List<Company> children = new ArrayList<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) {
        System.out.println("depth:" + depth + ",name:" + name);
        for (Company company : children) {
            company.display(depth + 2);
        }
    }

    @Override
    public void lineOfDuty() {
        for (Company company : children) {
            company.lineOfDuty();
        }
    }
}

人力资源部与财务部类 树叶节点

/**
 * 人力资源部
 * Created by ZhuPengWei on 2018/1/29.
 */
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) {
        System.out.println("depth:" + depth + ",name:" + name);
    }

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

/**
 * 财务部
 * Created by ZhuPengWei on 2018/1/29.
 */
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) {
        System.out.println("depth:" + depth + ",name:" + name);
    }

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

客户端

/**
 * 客户端
 * Created by ZhuPengWei on 2018/1/29.
 */
public class Client {
    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("南京办事处财务部"));
        comp.add(comp1);

        System.out.println("----------结构图----------");
        root.display(1);

        System.out.println("----------职责----------");
        root.lineOfDuty();
    }
}

组合模式的好处
组合模式这样就定义了包含人力资源部和财务部这些基本对象和分公司、办事处等组合对象的类层次结构。
基本对象可以被组合成更加复杂的对象，而这个组合对象又可以被组合，这样不断的递归下去，客户代码中，
任何用到基本对象的地方都可以使用组合对象了。