组合模式

组合模式 - 物以类聚

用代码来表示树形结构，将一组相似的对象做一组对象处理，提供一个统一的方法访问相应的对象，以此忽略对象与对象之间的差别。

使用场景

表示对象的部分-整体层次结构时
从一个整体中能够独立出部分模块或者功能的场景

组合模式角色

Component

抽象根节点，用于管理和访问Component子节点。可在递归结构中定义一个接口，用于访问一个父节点，并在合适的情况下实现它。

Composite

枝干节点，继承自Component，存储子节点，实现和子节点相关的操作，如增加(add)和删除(remove)等。

Leaf

叶子节点，叶子节点没有子节点，

安全组合模式和透明组合模式

安全组合模式是直接依赖于实现类，与依赖倒置原则相违背。 但区分叶子节点和枝干节点容易。
透明组合模式是依赖于抽象类，符合依赖倒置原则。但不管是叶子节点(没有子节点)还是枝干节点都有着相同的结构，那意味着我们无法通过getChildren方法得到子节点的类型，而必须在方法实现的内部进行判断。

安全模式UML

透明模式UML

组合模式通用代码(透明模式)

Component

/**
 * 抽象根节点
 * 抽象根结果，为组合中的对象声明接口。
 * 在适合的情况下，实现所有类共有接口的缺省行为。
 * 声明一个接口用于访问和管理Component的子节点。
 * 可以在递归结构中定义一个接口，用于访问一个父节点，并在适合的情况下实现它。
 */
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);
}

Composite

/**
 * 具体枝干节点
 * 定义有子节点的那些枝干节点的行为，存储子节点，
 * 在Component接口中实现与子节点有关的操作。
 */
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 (null != components) {
            for (Component c : components) {
                c.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);
    }
}

Leaf

/**
 * 具体叶子节点
 * 在组合中表示叶子节点对象，叶子节点没有子节点，在组合中定义节点的行为。
 * Created by EthanCo on 2016/7/17.
 */
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("叶子节点没有子节点");
    }
}

Clinet

/**
 * 客户端
 * 通过Component接口操作接口节点的对象。
 * Created by EthanCo on 2016/7/17.
 */
public class Client {

    public static void main(String[] args) {
        //构造一个根节点
        Component root = new Composite("Root");

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

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

        //将叶子节点添加到枝干节点中
        root.addChild(branch1);
        root.addChild(branch2);

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

Android源码中的组合模式

Android中有一个非常经典的组合模式的实现，那就是View和ViewGroup。

其他

于 《Android源码设计模式解析与实战》 学习笔记