JAVA设计模式—组合模式笔记

简单案例：展示一个公司的层级
-----XXX公司-----  Company
----研发部---      Department
研发经理           Role
技术工程师
----财务部----
部长
出纳

组合模式基本介绍

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

组合模式原理图

原理图说明：

1. Component :这是组合中对象声明接口，在适当情况下，实现所有类共有的接口默认行为,用于访问和管理Component 子部件, Component  可以是抽象类或者接口
2. Leaf : 在组合中表示叶子节点，叶子节点没有子节点
3. Composite :非叶子节点，用于存储子部件，在 Component 接口中实现 子部件的相关操作，比如增加, 删除。

组合模式实现案例：

public abstract class Organization {
    private String name;
    private String synopsis;

    public Organization(String name, String synopsis) {
        this.name = name;
        this.synopsis = synopsis;
    }

    public String getName() {
        return name;
    }

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

    public String getSynopsis() {
        return synopsis;
    }

    public void setSynopsis(String synopsis) {
        this.synopsis = synopsis;
    }

    protected void add(Organization org) {
        throw new UnsupportedOperationException();
    }

    protected void remove(Organization org) {
        throw new UnsupportedOperationException();
    }

    protected abstract void show();
}

public class Company extends Organization{
    private List<Organization> orgList = new ArrayList<Organization>();

    public Company(String name, String synopsis) {
        super(name, synopsis);
    }

    @Override
    protected void add(Organization org) {
        orgList.add(org);
    }

    @Override
    protected void remove(Organization org) {
        orgList.remove(org);
    }

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

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

    @Override
    public void show() {
        System.out.println("-----" + getName() + "-----");
        for(Organization org : orgList) {
            org.show();
        }
    }
}

public class Department extends Organization{
    private List<Organization> orgList = new ArrayList<Organization>();

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

    @Override
    protected void add(Organization org) {
        orgList.add(org);
    }

    @Override
    protected void remove(Organization org) {
        orgList.remove(org);
    }

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

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

    @Override
    public void show() {
        System.out.println("----" + getName() + "----");
        for(Organization org : orgList) {
            org.show();
        }
    }
}

public class Role extends Organization{

    public Role(String name, String synopsis) {
        super(name, synopsis);
    }

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

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

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

public class TestDemo {
    public static void main(String[] args) {
        //创建公司
       Organization comp = new Company("科技公司","研究没用的科技");

       //创建部门
       Organization yfDep = new Department("研发部","研发点啥");
       Organization cwDep = new Department("财务部","没有钱的财务部");

       //创建职务
        Organization jingLi = new Role("研发经理","研发自己");
        Organization jiShu  = new Role("技术工程师","没钱不干活");

        Organization buZhang = new Role("财务部长","没钱的部长");
        Organization chuNa  = new Role("出纳","出不来");

        yfDep.add(jingLi);
        yfDep.add(jiShu);
        cwDep.add(buZhang);
        cwDep.add(chuNa);
        comp.add(yfDep);
        comp.add(cwDep);

        //comp.show();
        yfDep.show();

    }
}

组合模式说明：

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