23中设计模式之组合模式

组合模式也称为部分整体模式，结构型设计模式之一，组合模式比较简单，它将一组相似的对象看作一个对象处理，并根据一个树状结构来组合对象，然后提供一个统一的方法去访问相应的对象，以此忽略掉对象与对象集合之间的差别。

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

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

组合模式的UML类图

注意：组合模式分为透明模式和安全模式，透明的组合模式是指将组合所使用到的方法定义在抽象类的方式。安全模式是正好相反。这里的UML类图为透明的组合模式图。

角色介绍：

抽象构件角色（component）：是组合中的对象声明接口，在适当的情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件。

这个接口可 以用来管理所有的子对象。(可选)在递归结构中定义一个接口，用于访问一个父部件，并在合适的情况下实现它。

树叶构件角色(Leaf)：在组合树中表示叶节点对象，叶节点没有子节点。并在组合中定义图元对象的行为。

树枝构件角色（Composite）：定义有子部件的那些部件的行为。存储子部件。在Component接口中实现与子部件有关的操作。

客户角色（Client）：通过component接口操纵组合部件的对象。

源码的简单实现

Component.java类，透明组合模式的抽象根节点

//透明的组合模式抽象根节点
public abstract class Component {
    protected String name; // 节点名

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

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

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

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

    // 获取子节点
    public abstract Component getChildren(int index);
}

Composite.java类，透明组合模式具体枝干节点

// 透明组合模式具体枝干节点
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();
            }
        }
    }

    @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);
    }
}

Leaf.java类，透明的组合模式叶子节点

// 透明的组合模式叶子节点
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("叶子节点没有子节点");
    }
}

Client.java类，客户端

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

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

        // 构造两个叶子节点
        Leaf leaf1 = new Leaf("    叶子1");
        Leaf leaf2 = new Leaf("    叶子2");
        Leaf leaf3 = new Leaf("    叶子3");

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

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

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

输出结果：

根节点
  枝干1
    叶子1
    叶子2
  枝干2
    叶子3

组合模式的总结
组合模式的优点：

• 组合模式可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，它让高层模块忽略了层次的差异，方便对整个层次结构进行控制。
• 高层模块可以一致地使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合结构，简化了高层模块的代码。
• 在组合模式中增加新的枝干构件和叶子构件都很方便，无需对现有类库进行任何修改，符合“开闭原则”。
• 组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子对象和枝干对象的递归组合，可以形成复杂的树形结构，但对树形结构的控制却非常简单。

组合模式的缺点：

• 在新增构件时不好对枝干中的构件类型进行限制，不能依赖类型系统来施加这些约束，因为在大多数情况下，它们都来自于相同的抽象层，此时，必须进行类型检查来实现，这个实现过程较为复杂。