重学设计模式之组合模式

目录

• 定义
• 使用场景
• 代码实现

定义

组合模式也称为部分整体模式，它将对象组合成树形结构以表示“部分-整体”的层次结构，是的用户对单和对象和组合对象的使用具有一致性。通过组合模式用户可以将具有相似性的一组对象组合起来当作一个对象处理。

使用场景

1. 需要表示对象的部分-整体结构时。
2. 相同方式处理简单和复杂元素。
3. 从一个整体中能独立出部分模块或功能。

实现方式

1. 确保应用的核心模型能够以树状结构表示。尝试将其分解为简单元素和容器，容器必须能够同时包含简单元素和其他容器。
2. 声明组件接口及其一系列方法，这些方法对简单和复杂元素都有意义。
3. 创建一个叶节点类表示简单元素。程序中可以有多个不同的叶节点类。
4. 创建一个容器类表示复杂元素。在该类中，创建一个数组成员变量来存储对于其子元素的引用。该数组必须能够同时保存叶节点和容器，因此请确保将其声明为组合接口类型。实现组件接口方法时，住容器应该将大部分工作交给其子元素来完成。
5. 最后，在容器中定义添加和删除子元素的方法。这些操作可在组件接口中声明。这将会违反接口隔离原则，因为叶节点类中的这些方法为空。但是，这可以让客户端无差别地访问所有元素，即使是组成树状结构的元素。

代码实现

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> childs = new ArrayList<Component>();

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

    @Override
    public void doSomething() {
        System.out.println(name);
        for (Component child : childs) {
            child.doSomething();
        }
    }

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

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

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

public class ChildComposite extends Component {

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

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

    @Override
    public void doSomething() {
        System.out.println(name);
        for (Component child : childs) {
            child.doSomething();
        }
    }

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

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

    @Override
    public Component getChildren(int index) {
        return childs.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("也子节点没有子节点");
    }
}

public class CompositeTest {

    @Test
    public void test() {
        Composite composite = new Composite("Root");
        ChildComposite childComposite = new ChildComposite("Child Root");
        Leaf branch1 = new Leaf("Branch1");
        Leaf branch2 = new Leaf("Branch2");
        Leaf branch3 = new Leaf("Branch3");
        childComposite.addChild(branch3);
        composite.addChild(branch1);
        composite.addChild(branch2);
        composite.addChild(childComposite);
        composite.doSomething();
    }
}

Root
Branch1
Branch2
Child Root
Branch3
复制代码