设计模式之旅13--组合模式

1. 定义

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

组合模式

2. 使用场景

• 维护和展示部分-整体关系的场景，如树形菜单、关系型数据库、文件和文件夹管理。
• 从一个整体中能够独立出部分模块或功能的场景。
• Android中View与ViewGroup的设计就采用了组合模式。

3. 实现

这里以文件夹、文件为例子来实现（透明的）组合模式。

抽象构件角色：

/**
 * 抽象构件角色:定义参加组合对象的共有方法和属性，可以定义一些默认的行为或属性
 * 例子：文件夹、文件的抽象
 */
public abstract class Component {

    /**
     * 结点名。例子：文件夹/文件的名字
     */
    protected String mName;

    public Component(String name) {
        mName = name;
    }

    /**
     * 业务逻辑
     */
    public abstract void doSomething();

    /**
     * 添加结点。例子：添加文件夹/文件
     * @param component
     */
    public abstract void addChildren(Component component);

    /**
     * 删除结点。例子：删除文件夹/文件
     * @param component
     */
    public abstract void removeChildren(Component component);

    /**
     * 获取所有子结点。例子：获取所有子文件夹/文件
     * @return
     */
    public abstract List<Component> getChildrens();

}

树枝构件：

/**
 * 树枝构件：树枝对象，它的作用是组合树枝节点和叶子节点形成一个树形结构。
 * 例子：文件夹
 */
public class Composite extends Component {

    private List<Component> mChildrens = new ArrayList<>();

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

    @Override
    public void doSomething() {
        System.out.println("文件夹：" + this.mName);
    }

    @Override
    public void addChildren(Component component) {
        this.mChildrens.add(component);
    }

    @Override
    public void removeChildren(Component component) {
        this.mChildrens.remove(component);
    }

    @Override
    public List<Component> getChildrens() {
        return this.mChildrens;
    }
}

叶子构件：

/**
 * 叶子构件：叶子对象，其下再也没有其他的分支，也就是遍历的最小单位。
 * 例子：文件
 */
public class Leaf extends Component {

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

    @Override
    public void doSomething() {
        System.out.println("文件：" + this.mName);
    }

    @Override
    public void addChildren(Component component) {
        throw new UnsupportedOperationException("叶子结点不支持该操作");
    }

    @Override
    public void removeChildren(Component component) {
        throw new UnsupportedOperationException("叶子结点不支持该操作");
    }

    @Override
    public List<Component> getChildrens() {
        throw new UnsupportedOperationException("叶子结点不支持该操作");
    }
}

场景类：

public class Client {

    public static void main(String[] args) {
        Component c1 = new Composite("C盘");
        Component c2 = new Composite("文件夹A");
        Component c3 = new Leaf("文件A");
        Component c4 = new Leaf("文件B");

        c1.addChildren(c2);
        c1.addChildren(c3);
        c2.addChildren(c4);
    }

}

4. 优点

• 高层模块调用简单。高层模块不必关心自己处理的是单个对象还是整个组合结构，简化了高层模块的代码。
• 节点自由增加、删除。非常容易扩展，符合开闭原则，对以后的维护非常有利。

5. 缺点

• 普通的组合模式不符合依赖倒置原则，而透明的组合模式是符合的。
• 因为构件的抽象都是一样的，所以透明的组合模式在新增构件的时候不好对构件类型进行限制，容易产生运行时的异常。