认识设计模式（九）---组合模式

项目需求

编写一个程序展示一个学校院系结构，要求在一个页面中展示出学校的院系组成，一个大学有多个学院，一个学院有多个专业

传统的方案

1. 把学院看做是大学的子类，专业是学院的子类
2. 实际上要求是：在一个页面中展示出学校的学院和专业组成，一个学校有多个学院，一个学院有多个专业，因此这种方法不能很好的实现管理的操作，比如对学习院和专业的增加、删除、遍历
3. 解决方案：把学校、学院、专业都看作是组织结构，它们之间没有继承的关系，而是一个属性结构，可以更好的实现管理操作，也就是组合模式

组合模式

基本介绍

1. 组合模式又叫做部分整体模式，创了对象组的属性结构，把对象组合成树状结构来表示“整体-部分”的层次关系
2. 组合模式依据树型结构来组合对象，用来表示部分以及整体层次
3. 这种类型的设计模式属于结构型模式
4. 组合模式使得用户对单个对象和组合对象访问具有一致性，也就是说：组合模式能让客户以一致的方式处理个别对象以及组合对象

代码示例

（1）组织父类OrganizationComponent

public abstract class OrganizationComponent {
    //属性
    private String name;
    private String des;

    /**添加方法
     * @MethodName: add
     * @Author: AllenSun
     * @Date: 2020/3/2 21:13
     */
    protected void add(OrganizationComponent organizationComponent){
        //默认实现
        throw new UnsupportedOperationException();
    }

    /**抽象方法--打印
     * @MethodName: print
     * @Author: AllenSun
     * @Date: 2020/3/2 21:13
     */
    protected abstract void print();

    /**移除方法
     * @MethodName: remove
     * @Author: AllenSun
     * @Date: 2020/3/2 21:13
     */
    protected void remove(OrganizationComponent organizationComponent){
        throw new UnsupportedOperationException();
    }

    //构造器
    public OrganizationComponent(String name, String des){
        super();
        this.name=name;
        this.des=des;
    }

    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;
    }
}

（2）子类大学类College

//Universty其实就是Composite，可以管理College
public class Universty extends OrganizationComponent {

    List<OrganizationComponent> organizationComponents=new ArrayList<OrganizationComponent>();

    //构造器
    public Universty(String name, String des) {
        super(name, des);
    }

    /**重写add方法
     * @MethodName: add
     * @Author: AllenSun
     * @Date: 2020/3/2 21:14
     */
    @Override
    protected void add(OrganizationComponent organizationComponent) {
        organizationComponents.add(organizationComponent);
    }

    /**重写remove方法
     * @MethodName: remove
     * @Author: AllenSun
     * @Date: 2020/3/2 21:14
     */
    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        organizationComponents.remove(organizationComponent);
    }

    /**实现抽象方法，打印
     * @MethodName: print
     * @Author: AllenSun
     * @Date: 2020/3/2 21:14
     */
    @Override
    protected void print() {
        System.out.println("================"+getName()+"================");
        //遍历
        for (OrganizationComponent organizationComponent : organizationComponents) {
            organizationComponent.print();
        }
    }
}

（3）子类学院类

public class College extends OrganizationComponent {

    List<OrganizationComponent> organizationComponents=new ArrayList<OrganizationComponent>();

    //构造器
    public College(String name, String des) {
        super(name, des);
    }

    //重写add方法
    @Override
    protected void add(OrganizationComponent organizationComponent) {
        //将来实际业务中，College的add方法和University的add方法不一定完全相等
        organizationComponents.add(organizationComponent);
    }

    //重写remove方法
    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        organizationComponents.remove(organizationComponent);
    }

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

（4）子类专业类

public class Department extends OrganizationComponent {

    //叶子节点没有集合

    //构造器
    public Department(String name, String des) {
        super(name, des);
    }

    //add，remove方法不需要再写了，因为这是叶子节点

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

（5）测试类

public class Client {
    public static void main(String[] args) {
        //从大到小创建对象
        //创建大学
        OrganizationComponent universty=new Universty("清华大学","中国顶尖大学");
        //创建学院
        OrganizationComponent college1=new College("计算机学院","最赚钱的学院");
        OrganizationComponent college2=new College("工程学院","工程学院");
        OrganizationComponent college3=new College("文学院","文学院");
        OrganizationComponent college4=new College("外国语学院","外国语学院");
        //创建各个学院下面的专业
        college1.add(new Department("软件工程","软件工程不错"));
        college1.add(new Department("网络工程","网络工程不错"));
        college1.add(new Department("通信工程","通信工程不错"));
        college1.add(new Department("信息安全","信息安全不错"));
        college2.add(new Department("土木工程","土木工程不错"));
        college3.add(new Department("中国文学","中国文学不错"));
        college3.add(new Department("外国文学","外国文学不错"));
        college4.add(new Department("外交学","外交学不错"));
        college4.add(new Department("国际关系学","国际关系学不错"));

        //把学院加到大学里
        universty.add(college1);
        universty.add(college2);
        universty.add(college3);
        universty.add(college4);

        //输出
        System.out.println("打印整个大学");
        universty.print();
        System.out.println("打印计算机学院");
        college1.print();
    }
}

UML图

组合模式的注意事项和细节

1. 简化客户端操作，客户端只需要面对一致的对象而不用考虑整体部分或者节点叶子的问题
2. 具有较强的扩展性，当我们需要更改组合对象时，我们只需要调整内部的层次关系，客户端不用做出任何改动
3. 方便创建出胡复杂的层次结构，客户端不用理会组合里面的组成细节，容易添加节点或者叶子，从而创建出复杂的树形结构
4. 需要遍历组织机构，或者处理的对象具有树形结构时，非常适合使用组合模式
5. 要求讲好的抽象性，如果节点和叶子有很多差异性的话，比如很多方法和树形都不一样，不适合使用组合模式