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

    组合模式常用于树形结构，顶层的节点被称为根节点，根节点下面可以包含树枝节点和叶子节点，树枝节点下面又可以包含树枝节点和叶子节点

    image.png

    由上图可以看出，其实根节点和树枝节点本质上属于同一种数据类型，可以作为容器使用；而叶子节点与树枝节点在语义上不属于用一种类型。但是在组合模式中，会把树枝节点和叶子节点看作属于同一种数据类型（用统一接口定义），让它们具备一致行为。

    在组合模式中，整个树形结构中的对象都属于同一种类型，带来的好处就是用户不需要辨别是树枝节点还是叶子节点，可以直接进行操作，给用户的使用带来极大的便利。

    优点

    1. 组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码；
    2. 更容易在组合体内加入新的对象，满足“开闭原则”；


    缺点

    1. 设计较复杂，客户端需要花更多时间理清类之间的层次关系；
    2. 不容易限制容器中的构件；
    3. 不容易用继承的方法来增加构件的新功能；

    示例：
    在XML或HTML中，从根节点开始，每个节点都可能包含任意个其他节点，这些层层嵌套的节点就构成了一颗树。

    1. public class CompositeDemo {
    4.     // 节点接口
    5.     interface Node{
    6.         // 添加一个节点为子节点
    7.         Node add(Node node);
    8.         // 获取子节点
    9.         List<Node> children();
    10.         // 输出为XML
    11.         String toXml();
    12.     }
    14.     // 容器节点，可以包含任意个子节点
    15.     static class ElementNode implements Node {
    16.         private String name;
    17.         private List<Node> list = new ArrayList<>();
    19.         public ElementNode(String name) {
    20.             this.name = name;
    21.         }
    23.         public Node add(Node node) {
    24.             list.add(node);
    25.             return this;
    26.         }
    28.         public List<Node> children() {
    29.             return list;
    30.         }
    32.         public String toXml() {
    33.             String start = "<" + name + ">\n";
    34.             String end = "</" + name + ">\n";
    35.             StringJoiner sj = new StringJoiner("", start, end);
    36.             list.forEach(node -> {
    37.                 sj.add(node.toXml() + "\n");
    38.             });
    39.             return sj.toString();
    40.         }
    41.     }
    43.     // 普通节点
    44.     static class TextNode implements Node {
    45.         private String text;
    47.         public TextNode(String text) {
    48.             this.text = text;
    49.         }
    51.         public Node add(Node node) {
    52.             throw new UnsupportedOperationException();
    53.         }
    55.         public List<Node> children() {
    56.             return new ArrayList<>();
    57.         }
    59.         public String toXml() {
    60.             return text;
    61.         }
    62.     }
    64.     static class CommentNode implements Node {
    65.         private String text;
    67.         public CommentNode(String text) {
    68.             this.text = text;
    69.         }
    71.         public Node add(Node node) {
    72.             throw new UnsupportedOperationException();
    73.         }
    75.         public List<Node> children() {
    76.             return new ArrayList<>();
    77.         }
    79.         public String toXml() {
    80.             return "<!-- " + text + " -->";
    81.         }
    82.     }
    84.     public static void main(String[] args) {
    85.         Node root = new ElementNode("school");
    86.         root.add(new ElementNode("classA")
    87.                 .add(new TextNode("Tom"))
    88.                 .add(new TextNode("Alice")));
    89.         root.add(new ElementNode("classB")
    90.                 .add(new TextNode("Bob"))
    91.                 .add(new TextNode("Grace"))
    92.                 .add(new CommentNode("comment...")));
    93.         System.out.println(root.toXml());
    94.     }
    95. }

    输入如下

    <school>
<classA>
Tom
Alice
</classA>

<classB>
Bob
Grace
<!-- comment... -->
</classB>

</school>