组合模式

结构型模式

组合模式（Composite Pattern），又叫局部整体模式，是用于把一组类似的对象当作一个繁多的对象。组合模式根据树形构造来组合对象，用来示意局部以及整体档次。它创立了对象组的树形构造。

这种模式创立了一个蕴含本人对象组的类。该类提供了批改雷同对象组的形式。

介绍

用意： 将对象组合成树形构造以示意 ” 局部 - 整体 ” 的层次结构。组合模式使得用户对单个对象和组合对象的应用具备一致性。

次要解决： 它在咱们树型构造的问题中，含糊了简略元素和简单元素的概念，客户程序能够像解决简略元素一样来解决简单元素，从而使得客户程序与简单元素的内部结构解耦。

何时应用： 1、您想示意对象的局部 - 整体层次结构（树形构造）。2、您心愿用户疏忽组合对象与单个对象的不同，用户将对立地应用组合构造中的所有对象。

如何解决： 树枝和叶子实现对立接口，树枝外部组合该接口。

要害代码： 树枝外部组合该接口，并且含有外部属性 List，外面放 Component。

具体实现

应用学校院系业余来作为例子：

第一步：创立 Component

public abstract class OrganizationComponent {

    /**
     * 名字
     */
    private String name;

    /**
     * 阐明
     */
    private String des;

    public OrganizationComponent(String name, String des) {
        this.name = name;
        this.des = des;
    }

    protected void add(OrganizationComponent organizationComponent) {
        // 默认实现
        throw new UnsupportedOperationException();}

    protected void remove(OrganizationComponent organizationComponent) {
        // 默认实现
        throw new UnsupportedOperationException();}

    protected abstract void print();

    public String getName() {return name;}

    public void setName(String name) {this.name = name;}

    public String getDes() {return des;}

    public void setDes(String des) {this.des = des;}
}

第二步：创立学校

public class University extends OrganizationComponent {

    // 寄存院系
    List<OrganizationComponent> organizationComponents = new ArrayList<>();

    public University(String name, String des) {super(name, des);
    }

    @Override
    protected void add(OrganizationComponent organizationComponent) {
        // 业务逻辑...
        organizationComponents.add(organizationComponent);
    }

    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        // 业务逻辑...
        organizationComponents.remove(organizationComponent);
    }

    @Override
    protected void print() {System.out.println("------" + getName() + "------");
        for (OrganizationComponent component : organizationComponents) {component.print();
        }
    }
}

第三步：创立院系

public class College extends OrganizationComponent {

    //List 中寄存的是 Department
    List<OrganizationComponent> organizationComponents = new ArrayList<>();

    public College(String name, String des) {super(name, des);
    }

    @Override
    protected void add(OrganizationComponent organizationComponent) {
        // 业务逻辑...
        organizationComponents.add(organizationComponent);
    }

    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        // 业务逻辑...
        organizationComponents.remove(organizationComponent);
    }

    @Override
    protected void print() {System.out.println("------" + getName() + "------");
        for (OrganizationComponent component : organizationComponents) {component.print();
        }
    }
}

第四步：创立业余（叶子节点）

public class Department extends OrganizationComponent {public Department(String name, String des) {super(name, des);
    }

    @Override
    protected void print() {System.out.println(getName());
    }
}

第五步：创立测试

public class Client {public static void main(String[] args) {
        // 从大到小创建对象 学校
        OrganizationComponent university = new University("清华大学", "中国顶尖大学");
        // 创立学院
        OrganizationComponent computerCollege = new College("计算机学院", "最好的计算机学院");
        OrganizationComponent infoEngineerCollege = new College("信息工程学院", "最好的信息工程学院");

        // 创立各个学院上面的系 (业余)
        computerCollege.add(new Department("软件工程", "不错的软件工程"));
        computerCollege.add(new Department("网络工程", "不错的网络工程"));
        computerCollege.add(new Department("计算机科学与技术", "不错的计算机科学与技术"));

        infoEngineerCollege.add(new Department("通信工程", "挺难"));
        infoEngineerCollege.add(new Department("信息工程", "不好学"));

        university.add(computerCollege);
        university.add(infoEngineerCollege);

        university.print();
        //computerCollege.print();}
}

运行如下：

------ 清华大学 ------
------ 计算机学院 ------
软件工程
网络工程
计算机科学与技术
------ 信息工程学院 ------
通信工程
信息工程 

长处：

    1、高层模块调用简略。2、节点自在减少。

毛病：

    在应用组合模式时，其叶子和树枝的申明都是实现类，而不是接口，违反了依赖倒置准则。