Java设计模式之--组合模式(Composite Pattern)

概念：

组合模式(Composite Pattern)

组合模式，将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。

有时候又叫做部分-整体模式，它使我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以像处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。

组合模式经典案例：系统目录结构，网站导航结构等。

其类结构图如下：

案例，现规划方案实现某科技公司业务部门结构

代码：

部门类：

public abstract class Depat {
    private String name;
    private List<Depat> subDepat;
    private Depat parent;

    public abstract Depat addSubDepatment(Depat depasub);

    public abstract Depat removeSubDepatment(Depat depasub);

    public abstract Depat display();


    public Depat() {
    }

    public Depat(String depatname) {
        setName(depatname);
    }

    public Depat getParent() {
        return parent;
    }

    public void setParent(Depat parent) {
        this.parent = parent;
    }

    public List<Depat> getSubDepat() {
        return subDepat;
    }

    public void setSubDepat(List<Depat> subDepat) {
        this.subDepat = subDepat;
    }

    public String getName() {
        return name;
    }

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

}

public class Depatment extends Depat{
    public Depatment() {
        super();
        setSubDepat(new ArrayList<Depat>());
    }

    public Depatment(String depatmentname) {
        super(depatmentname);
        setSubDepat(new ArrayList<Depat>());
    }

    @Override
    public Depat addSubDepatment(Depat depasub) {
        depasub.setParent(this);
        getSubDepat().add(depasub);
        return this;
    }

    @Override
    public Depat removeSubDepatment(Depat depasub) {
        depasub.setParent(null);
        getSubDepat().remove(depasub);
        return this;
    }

    @Override
    public Depat display() {
        System.out.println(String.format("%s", this.getName()));
        for(Depat depat : getSubDepat()){
            depat.display();
        }
        return this;
    }
}

Company类

public class Company {
    Depatment root = null;

    public Depatment getRoot() {
        return root;
    }

    public void setRoot(Depatment root) {
        this.root = root;
    }


    public Company(String Name) {
        root = new Depatment(Name);
    }
}

测试类：

public class WorkClass {
    public void test() {
        Company company = new Company("某科技公司");
        company.getRoot().addSubDepatment(
                new Depatment("笔电大部").
                        addSubDepatment(new Depatment("笔电硬件研发部").
                                addSubDepatment(new Depatment("笔电硬件北京研发部")).
                                addSubDepatment(new Depatment("笔电硬件深圳研发部"))).
                        addSubDepatment(new Depatment("笔电软件研发部").
                                addSubDepatment(new Depatment("笔电软件杭州研发部")).
                                addSubDepatment(new Depatment("笔电软件苏州研发部"))))
                .addSubDepatment(
                new Depatment("手机大部").
                        addSubDepatment(new Depatment("手机硬件研发部").
                                addSubDepatment(new Depatment("手机硬件北京研发部")).
                                addSubDepatment(new Depatment("手机硬件深圳研发部"))).
                        addSubDepatment(new Depatment("手机软件研发部").
                                addSubDepatment(new Depatment("手机软件杭州研发部")).
                                addSubDepatment(new Depatment("手机软件苏州研发部"))));
        company.getRoot().display();
    }
}

输出：

06-21 09:19:32.954 12750-12750/com.example.qinghua_liu.myapplication I/System.out: 某科技公司
06-21 09:19:32.954 12750-12750/com.example.qinghua_liu.myapplication I/System.out: 笔电大部
06-21 09:19:32.954 12750-12750/com.example.qinghua_liu.myapplication I/System.out: 笔电硬件研发部
06-21 09:19:32.954 12750-12750/com.example.qinghua_liu.myapplication I/System.out: 笔电硬件北京研发部
06-21 09:19:32.954 12750-12750/com.example.qinghua_liu.myapplication I/System.out: 笔电硬件深圳研发部
06-21 09:19:32.954 12750-12750/com.example.qinghua_liu.myapplication I/System.out: 笔电软件研发部
06-21 09:19:32.954 12750-12750/com.example.qinghua_liu.myapplication I/System.out: 笔电软件杭州研发部
06-21 09:19:32.954 12750-12750/com.example.qinghua_liu.myapplication I/System.out: 笔电软件苏州研发部
06-21 09:19:32.954 12750-12750/com.example.qinghua_liu.myapplication I/System.out: 手机大部
06-21 09:19:32.954 12750-12750/com.example.qinghua_liu.myapplication I/System.out: 手机硬件研发部
06-21 09:19:32.954 12750-12750/com.example.qinghua_liu.myapplication I/System.out: 手机硬件北京研发部
06-21 09:19:32.954 12750-12750/com.example.qinghua_liu.myapplication I/System.out: 手机硬件深圳研发部
06-21 09:19:32.954 12750-12750/com.example.qinghua_liu.myapplication I/System.out: 手机软件研发部
06-21 09:19:32.954 12750-12750/com.example.qinghua_liu.myapplication I/System.out: 手机软件杭州研发部
06-21 09:19:32.954 12750-12750/com.example.qinghua_liu.myapplication I/System.out: 手机软件苏州研发部

结语：

组合模式(Composite Pattern)它使我们树型结构的问题中，模糊了简单元素和复杂元素的概念
   ，客户程序可以向处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。组合模式让你可以优化处理递
   归或分级数据结构。有许多关于分级数据结构的例子，使得组合模式非常有用武之地。