组合模式——物以类聚

（《设计模式解析与实战——何红辉，关爱民》读书笔记）

一、定义
将对象组合呈树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。
比如，总公司下设总公司行政部、总公司研发部和子公司，而子公司又下设子公司行政部和子公司研发部。

二、使用场景
(1)表示对象的部分-整体层次结构时；
(2)从一个整体中能够独立出部分模块或功能的场景。

三、组合模式的通用模式代码
1、安全的组合模式

/**
 * 抽象根节点：为组合中的对象声明接口
 */
public abstract class Component {
    // 节点名
    protected String name;

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

    /**
     * 具体的逻辑方法由子类实现
     */
    public abstract void doSomething();
}

/**
 * 具体枝干节点：定义有子节点的那些枝干节点的行为，存储子节点
 */
public class Composite extends Component {

    /*
     * 存储节点的容器
     */
    private List<Component> components = new ArrayList<>();

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

    @Override
    public void doSomething() {
        System.out.println(name);
        if (components != null) {
            for (Component component : components) {
                component.doSomething();
            }
        }
    }

    /**
     * 添加子节点
     * 
     * @param child
     *            子节点
     */
    public void addChild(Component child) {
        components.add(child);
    }

    /**
     * 移除子节点
     * 
     * @param child
     *            子节点
     */
    public void removeChild(Component child) {
        components.remove(child);
    }

    /**
     * 获取子节点
     * 
     * @param index
     *            子节点对应下标
     * @return 子节点
     */
    public Component getChildren(int index) {
        return components.get(index);
    }
}

/**
 * 具体叶子节点：叶子节点没有子节点，在组合中定义节点对象的行为
 */
public class Leaf extends Component{

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

    @Override
    public void doSomething() {
        System.out.println(name);
    }
}

/**
 * 客户类：通过Component接口操纵组合节点的对象
 */
public class Client {
    public static void main(String[] args) {
        // 构造一个根节点
        Composite root = new Composite("Root");

        // 构造两个枝干节点
        Composite branch1 = new Composite("Branch1");
        Composite branch2 = new Composite("Branch2");

        // 构造两个叶子节点
        Leaf leaf1 = new Leaf("Leaf1");
        Leaf leaf2 = new Leaf("Leaf2");

        // 将叶子节点添加至枝干节点中
        branch1.addChild(leaf1);
        branch2.addChild(leaf2);

        // 将枝干节点添加至根节点中
        root.addChild(branch1);
        root.addChild(branch2);

        // 执行方法
        root.doSomething();
    }
}

运行结果：

这里有一个很大的弊端，我们在客户类中直接使用了Component的实现类，这与依赖倒置原则（高层次的模块不依赖于低层次的模块的实现细节的目的）相违背。

2、透明的组合模式

/**
 * 透明的组合模式抽象根节点：为组合中的对象声明接口
 */
public abstract class Component {
    // 节点名
    protected String name;

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

    /**
     * 具体的逻辑方法由子类实现
     */
    public abstract void doSomething();

    /**
     * 添加子节点
     * 
     * @param child
     *            子节点
     */
    public abstract void addChild(Component child);

    /**
     * 移除子节点
     * 
     * @param child
     *            子节点
     */
    public abstract void removeChild(Component child);

    /**
     * 获取子节点
     * 
     * @param index
     *            子节点对应下标
     * @return 子节点
     */
    public abstract Component getChildren(int index);
}

/**
 * 透明的组合模式具体枝干节点：定义有子节点的那些枝干节点的行为，存储子节点
 */
public class Composite extends Component {

    /*
     * 存储节点的容器
     */
    private List<Component> components = new ArrayList<>();

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

    @Override
    public void doSomething() {
        System.out.println(name);
        if (components != null) {
            for (Component component : components) {
                component.doSomething();
            }
        }
    }

    @Override
    public void addChild(Component child) {
        components.add(child);
    }

    @Override
    public void removeChild(Component child) {
        components.remove(child);
    }

    @Override
    public Component getChildren(int index) {
        return components.get(index);
    }
}

/**
 * 透明的组合模式具体叶子节点：叶子节点没有子节点，在组合中定义节点对象的行为
 */
public class Leaf extends Component {

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

    @Override
    public void doSomething() {
        System.out.println(name);
    }

    @Override
    public void addChild(Component child) {
        throw new UnsupportedOperationException("叶子节点没有子节点");
    }

    @Override
    public void removeChild(Component child) {
        throw new UnsupportedOperationException("叶子节点没有子节点");
    }

    @Override
    public Component getChildren(int index) {
        throw new UnsupportedOperationException("叶子节点没有子节点");
    }
}

/**
 * 透明的组合模式客户类：通过Component接口操纵组合节点的对象
 */
public class Client {
    public static void main(String[] args) {
        // 构造一个根节点
        Component root = new Composite("Root");

        // 构造两个枝干节点
        Component branch1 = new Composite("Branch1");
        Component branch2 = new Composite("Branch2");

        // 构造两个叶子节点
        Component leaf1 = new Leaf("Leaf1");
        Component leaf2 = new Leaf("Leaf2");

        // 将叶子节点添加至枝干节点中
        branch1.addChild(leaf1);
        branch2.addChild(leaf2);

        // 将枝干节点添加至根节点中
        root.addChild(branch1);
        root.addChild(branch2);

        // 执行方法
        root.doSomething();
    }
}

四、总结
组合模式在Android中最经典的实现就是View和ViewGrounp的嵌套组合。当然这种模式真正需要开发者去实现的并不多。
优点：
(1)可以清楚的定义分层次的复杂对象，表示对象的全部或部分层次，它让高层模块忽略了层次的差异，方便对整个层次结构进行控制；
(2)高层模块可以一致的使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合结构，简化了高层模块的代码；
(3)在组合模式中增加新的枝干构件和叶子构件都很方便，无须对现有类库进行任何修改，符合“开闭原则”；
(4)组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子对象和枝干对象的递归组合，可以形成复杂的树形结构，但对树形结构的控制却非常简单。
缺点：
在新增构件时不好对枝干中的构件类型进行限制，不能依赖类型系统来施加这些约束，因为在大多数情况下，它们都来自于相同的抽象层，此时，必须及时进行类型检查来实现，这个实现过程较为复杂。