设计模式-组合模式

问题背景

我们来看一个学校院系的展示需求，如下图：

解决方案：组合模式

下面是组合模式的UML类图：

我们创建一个OrganizationComponent的抽象类表示组织，它定义了基本信息：name是组织的名称，add方法可以增加下级组织，remove可以移除下级组织，print可以打印自己包括下级组织的名称。

• Department作为系，最基础的部门，没有下级部门，只需要实现OrganinzationComponent抽象类，实现打印自己的名称即可
• College作为学院，Department的上级部门，所以College要创建一个List来存放Department，还有实现add、remove方法，print方法要实现打印自己名称和下级部门的名称。
• University作为学校，College的上级部门，实现的内容同College一样。

代码实现

组织抽象类

/**
 * 组织
 */
public abstract class OrganizationComponent {

    /**
     * 名称
     */
    private String name;

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

    public String getName() {
        return name;
    }

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

    /**
     * 添加
     *
     * @param organizationComponent
     */
    public void add(OrganizationComponent organizationComponent) {
        throw new UnsupportedOperationException();
    }

    /**
     * 删除
     *
     * @param organizationComponent
     */
    public void remove(OrganizationComponent organizationComponent) {
        throw new UnsupportedOperationException();
    }

    /**
     * 打印组织
     */
    public abstract void print();
}

大学类

/**
 * 大学
 */
public class University extends OrganizationComponent{

    /**
     * 存放学院College
     */
    private List<OrganizationComponent> org = new ArrayList<>();

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

    /**
     * 重写add方法
     *
     * @param organizationComponent
     */
    @Override
    public void add(OrganizationComponent organizationComponent) {
        org.add(organizationComponent);
    }

    /**
     * 重写remove方法
     *
     * @param organizationComponent
     */
    @Override
    public void remove(OrganizationComponent organizationComponent) {
        org.remove(organizationComponent);
    }

    /**
     * 重新打印方法
     *
     */
    @Override
    public void print() {
        System.out.println("学校：" + getName());
        for (OrganizationComponent organizationComponent : org) {
            organizationComponent.print();
        }
    }
}

学院类

/**
 * 学院
 */
public class College extends OrganizationComponent{

    /**
     * 存放系Department
     */
    private List<OrganizationComponent> org = new ArrayList<>();

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

    /**
     * 重写add方法
     *
     * @param organizationComponent
     */
    @Override
    public void add(OrganizationComponent organizationComponent) {
        org.add(organizationComponent);
    }

    /**
     * 重写remove方法
     *
     * @param organizationComponent
     */
    @Override
    public void remove(OrganizationComponent organizationComponent) {
        org.remove(organizationComponent);
    }

    /**
     * 重新打印方法
     *
     */
    @Override
    public void print() {
        System.out.println("学院：" + getName());
        for (OrganizationComponent organizationComponent : org) {
            organizationComponent.print();
        }
    }
}

系类

/**
 * 系
 */
public class Department extends OrganizationComponent{

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

    /**
     * 重新打印方法
     *
     */
    @Override
    public void print() {
        System.out.println("系：" + getName());
    }
}

Client类

public class Client {
    public static void main(String[] args) {
        // 从大到小

        // 创建大学
        University university = new University("清华大学");

        // 创建学院
        College college1 = new College("计算机学院");
        College college2 = new College("信息工程学院");

        // 创建系
        college1.add(new Department("软件工程"));
        college1.add(new Department("网络工程"));
        college1.add(new Department("计算机科学与技术"));

        college2.add(new Department("通信工程"));
        college2.add(new Department("信息工程"));

        university.add(college1);
        university.add(college2);

        // 打印整个大学的组织架构
        university.print();

        // 打印计算机学院的组织架构
        // college1.print();

    }
}

运行结果：

注意事项和细节

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

我一开始想到的实现方法

我们应该可以直接想到这样去设计：

University(大学)是一个类，name是学校的名称，collegeList可以存储学校的所有学院。
College(学院)是一个抽象类，name是学院的名称，departmentList可以存储学院下所有的系。
Department(系)是一个抽象类，name是系的名称。
print方法可以打印名称。
所有的学院都需要继承College然后才能增加到University类中，所有的系都要继承Department才能增加到College中。

与组合模式的差别

1、即使实现下来基本都差不多感觉
2、组合模式的University也是一个组织，可以动态插入更高级的组织，而我想到的Universite只是一个普通类，扩展性没有组合模式好
3、我的实现多写了两个抽象方法College和Department，组合模式将这个抽象为更高层次的OrganizationComponent

GitHub源码

design-patterns