23种设计模式-组合模式

基本介绍：

1. 反应整体和部分的关系
2. 组合模式依据树形结构来组合对象，用来表示部分以及整体层次

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

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

    //方法print，做成抽象的，子类都需要实现
    protected abstract void print();
}

public class University extends OrganizationComponent {
    List<OrganizationComponent> organizationComponents=new ArrayList<OrganizationComponent>();

    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
    public String getName() {
        return super.getName();
    }

    @Override
    public String getDes() {
        return super.getDes();
    }

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

public class College extends OrganizationComponent {

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

    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
    public String getName() {
        return super.getName();
    }

    @Override
    public String getDes() {
        return super.getDes();
    }

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

    }
}

public class Department extends OrganizationComponent {

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

    @Override
    public String getName() {
        return super.getName();
    }

    @Override
    public String getDes() {
        return super.getDes();
    }

    @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("网络工程","网络工程不错"));
        infoEngineercollege.add(new Department("信息工程","信息工程不错"));
        infoEngineercollege.add(new Department("通信工程","通信工程不错"));
        university.add(computerCollege);
        university.add(infoEngineercollege);
        university.print();
    }
}

组合模式就是对聚合的使用，在学院和部门间再加一个组组织，不需要修改原先内容，很好的实现了扩展，开闭原则。

回顾七大原则：
单一职责原则：一个类一个职责
接口隔离原则：没有接口
依赖倒转原则：用抽象类不用具体子类
里氏替换原则：不重写父类的方法，这里add和remove本身应该写成抽象，因为叶子节点不需要重写这两个方法，所以就没有抽象，后面不同composite（非叶子节点）具体重写成自己的需要，add和remove写在父类中虽然不是抽象，但是还是抽象思想的作用。
迪米特法则：没有使用间接对象，属性私有化，继承用protect
开闭原则：在学院和部门间再加一个组织，不需要修改原先内容
组合复用原则：用合成/聚合代替继承，组合模式其实就是对聚合的使用，就是为了满足组合复用原则。