一、白话

 使用树形结构的将所有的组件组合起来。例如一台电脑由显示器，主机，键盘，鼠标组合而成，主机由硬盘，风扇，cpu,内存条组成，风扇又由扇片，电机组成，整个组织组合起来就展现出来了一种树状的接口。而把所有的部件组合起来的技术就叫组合模式。

二、定义

  将对象组合成树形结构来表示“部分-整体”的层次结构。组合模式使得客户能以一致的方式处理个别对象和组合对象。

  组合模式中的角色：

• Component抽象组件：为组合中所有对象提供一个接口，不管是叶子对象还是组合对象。
• Composite组合节点对象：实现了Component的所有操作，并且持有子节点对象。
• Leaf叶节点对象：叶节点对象没有任何子节点，实现了Component中的某些操作。

三、示例

/**
 * 抽象组件角色-定义统一的变量和函数
 */
public abstract class Component {
    protected String name;

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

    // 统一方法，需要所有子类实现。 同时所有子类需要让子类执行，直到叶子节点执行。保证整个组织结构统一执行
    public abstract void operation();

    // 统一方法，子类非必要实现,未实现的不支持调用
    public void add(Component component){
        throw new UnsupportedOperationException();
    }
    public void remove(Component component){
        throw new UnsupportedOperationException();
    }
    public Component getChild(int i){
        throw new UnsupportedOperationException();
    }
    public List<Component> getChilds(Component component){
        return null;
    }
}

/**
 * 组合节点对象角色-树状结构的各个组件的连接点
 */
public class Composite extends Component {
    // 子类的所有节点
    List<Component> components = new ArrayList<>();

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

    @Override
    public void operation() {
        System.out.println(name + "操作成功");
        for (int i = 0; i < components.size(); i++) {
            components.get(i).operation();
        }
    }

    // 以下方法都只是做了简单实现
    public void add(Component component){
        components.add(component);
    }
    public void remove(Component component){
        components.remove(component);
    }
    public Component getChild(int i){
        return components.get(i);
    }
    public List<Component> getChilds(Component component){
        return components;
    }
}

/**
 * 叶子节点角色-最小的拆分单元
 */
public class Leaf extends Component {

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

    @Override
    public void operation() {
        System.out.println(name + "操作成功");
    }
}

// 客户端调用
public class CompositeApplication {
    // 调用
    public static void main(String[] args) {
        // 根节点
        Composite rootComponent = new Composite("根节点");

        // 新增子节点1，子节点2 并加入根节点
        Composite composite1 = new Composite("组合节点1");
        Composite composite2 = new Composite("组合节点2");
        rootComponent.add(composite1);
        rootComponent.add(composite2);

        // 节点2 新增叶子节点11
        Composite leaf1 = new Composite("叶子节点21");
        composite2.add(leaf1);

        // 子节点1 新增子节点11
        Composite composite11 = new Composite("组合节点11");
        composite1.add(composite11);

        // 子节点11 新增 叶子节点111
        Composite leaf111 = new Composite("叶子节点111");
        composite11.add(leaf111);

        // 根节点调用统一方法，所有子节点都依次调用
        rootComponent.operation();
    }
}

输出示例：

根节点操作成功
组合节点1操作成功
组合节点11操作成功
叶子节点111操作成功
组合节点2操作成功
叶子节点21操作成功

四、总结

  优点：

• 组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码；
• 更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足“开闭原则”；

 例如，计算电脑价格，只需要操作相应的组合节点，就能知道所有子节点的价格。无需单独处理。