组合模式

import java.util.LinkedList;
import java.util.List;

/**
 *  组合模式
 * 个人理解：1.为了解决整体—部分构成的问题，如树、组织部门
 *  2.抽象类既可以表示叶子节点，也可以表示树枝节点
 *  3.一般来说，叶子节点中不含有add等方法，如果有，是为了兼容抽象类，需要抛出异常
 * 组件：抽象类（Component，用以定义一个节点）、叶子节点（Leaf，没有相关的节点操作）、
 *  树枝节点（Composite，可以操作子节点）、客户类（Client）
 */
public class CompositeDesignPattern {

    public static void main(String[] args) {
        Composite tree = new Composite("根节点");
        Composite treeA1 = new Composite("A1");
        Composite treeA2 = new Composite("A2");
        tree.add(treeA1);
        tree.add(treeA2);
        Component treeB11 = new Leaf("B11");
        Component treeB12 = new Leaf("B12");
        treeA1.add(treeB11);
        treeA1.add(treeB12);
        Component treeB21 = new Leaf("B21");
        treeA2.add(treeB21);

        tree.operate(0);
    }

}

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

    public abstract void operate(int depth);
}

class Leaf extends Component {

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

    @Override
    public void operate(int depth) {
        System.out.println(name);
    }
}

class Composite extends Component {
    private List<Component> components;

    public Composite(String name) {
        super(name);
        components = new LinkedList<>();
    }

    @Override
    public void operate(int depth) {
        System.out.println(name);
        for (Component component : components) {
            component.operate(depth+1);
        }
    }

    public void add(Component component) {
        components.add(component);
    }

    public void remove(Component component) {
        components.remove(component);
    }

    public void removeAll() {
        components.clear();
    }
}