1.概述

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

2.示例

Component 为组合中的对象声明接口，在适当情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理 Component 的子部件。
Component.java

public abstract class Component {
    protected String name;

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

    // 通常都用Add和 Remove方法来提供增加或移除树叶或树枝的功能
    public abstract void add(Component c);

    public abstract void remove(Component c);

    public abstract void display(int depth);
}

Composite 定义有枝节点行为，用来存储子部件，在 Component 接口中实现与子部件有关的操作，比如增加 Add 和删除 Remove。
Composite.java

public class Composite extends Component {
    // 一个子对象集合用来存储其下属的枝节点和叶节点
    private List<Component> children = new ArrayList<>();

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

    @Override
    public void add(Component c) {
        children.add(c);
    }

    @Override
    public void remove(Component c) {
        children.remove(c);
    }

    // 显示其枝节点名称，并对其下级进行遍历
    @Override
    public void display(int depth) {
        System.out.println(new String(new char[depth]).replace("\0", "-")+name);
        for (Component child : children) {
            child.display(depth + 2);
        }
    }
}

Leaf 在组合中表示叶节点对象，叶节点没有子节点。
Leaf.java

public class Leaf extends Component {
    public Leaf(String name) {
        super(name);
    }

    // 由于叶子没有再增加分枝和树叶，所以 Add和Remove方法实现它没有意义，
    // 但这样做可以消除叶节点和枝节点对象在抽象层次的区别，它们具备完全一致的接口
    @Override
    public void add(Component c) {
        System.out.println("Cannot add to a leaf");
    }

    @Override
    public void remove(Component c) {
        System.out.println("Cannot remove to a leaf");
    }

    // 叶节点的具体方法，此处是显示其名称和级别
    @Override
    public void display(int depth) {
        System.out.println(new String(new char[depth]).replace("\0", "-") + name);
    }
}

客户端。
Client.java

public class Client {
    public static void main(String[] args) {
        // 生成树根 root，根上长出两叶 LeafA和 LeafB
        Composite root = new Composite("root");
        root.add(new Leaf("Leaf A"));
        root.add(new Leaf("Leaf B"));

        // 根上长出分枝 Composite X，分枝上也有两叶 Leaf XA 和 Leaf XB
        Composite comp = new Composite("Composite X");
        comp.add(new Leaf("Leaf XA"));
        comp.add(new Leaf("Leaf XB"));
        root.add(comp);

        // 在 Composite X上再长出分枝 Composite XY，分枝上也有两叶 Leaf XYA 和 Leaf XYB
        Composite comp2 = new Composite("Composite XY");
        comp2.add(new Leaf("Leaf XYA"));
        comp2.add(new Leaf("Leaf XYB"));
        comp.add(comp2);

        root.add(new Leaf("Leaf C"));
        Leaf leafD = new Leaf("Leaf D");
        root.add(leafD);
        root.remove(leafD);

        root.display(1);
    }
}

输出如下。

-root
---Leaf A
---Leaf B
---Composite X
-----Leaf XA
-----Leaf XB
-----Composite XY
-------Leaf XYA
-------Leaf XYB
---Leaf C

Process finished with exit code 0

3.透明方式与安全方式

• 透明方式
  Component 中声明所有用来管理子对象的方法，其中包括 Add、Remov e等。这样实现 Component 接口的所有子类都具备了 Add 和 Remove 。这样做的好处就是叶节点和枝节点对于外界没有区别，它们具备完全一致的行为接口。但问题也很明显，因为 Leaf 类本身不具备Add、Remove 方法的功能，所以实现它是没有意义的。
• 安全方式
  Component 接口中不去声明 Add 和 Remove 方法，那么子类的 Leaf 也就不需要去实现它，而是在 Composite 声明所有用来管理子类对象的方法，这样做就不会出现刚才提到的问题，不过由于不够透明，所以树叶和树枝类将不具有相同的接口，客户端的调用需要做相应的判断，带来了不便。

4.使用与优点

• 当需求中是体现部分与整体层次的结构时，以及希望用户可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象时，就应该考虑用组合模式了。
• 组合模式定义了包含基本对象和组合对象的类层次结构。基本对象可以被组合成更复杂的组合对象，而这个组合对象又可以被组合这样不断地递归下去，客户代码中，任何用到基本对象的地方都可以使用组合对象了。
• 用户是不用关心到底是处理一个叶节点还是处理一个组合组件，也就用不着为定义组合而写一些选择判断语句了。即组合模式让客户可以一致地使用组合结构和单个对象。

参考书籍：
《大话设计模式》