组合模式：Composite Pattern，又叫作整体-部分（Part-Whole）模式，它的宗旨是通过将单个对象（叶子节点）和组合对象（树枝节点）用相同的接口进行表示，使得客户对单个对象和组合对象的使用具有一致性，属于结构型设计模式

    组合模式一般用于描述整体和部分的关系，将对象组织到树形结构中

    • 顶层的节点被称为根节点
    • 根节点下面可以包含树枝节点和叶子节点
    • 树节点下面又可以包含树枝节点和叶子节点

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

    组合模式的一般用途：

    • 希望客户端可以忽略组合对象和单个对象的差异
    • 对象层次具备整体和部分，呈树形结构

    UML 图：
    image.png
    通用写法：

    1. public class CompositeDemo {
    2.     public static void main(String[] args) {
    3.         // 创建根结点
    4.         Component root = new Composite("root");
    5.         // 创建一个树枝节点
    6.         Component branchA = new Composite("---branchA");
    7.         Component branchB = new Composite("------branchB");
    8.         // 创建叶子节点
    9.         Component leafA = new Leaf("------leafA");
    10.         Component leafB = new Leaf("---------leafB");
    11.         Component leafC = new Leaf("---leafC");
    13.         // 节点组装
    14.         root.addChild(branchA);
    15.         root.addChild(leafC);
    17.         branchA.addChild(leafA);
    18.         branchA.addChild(branchB);
    20.         branchB.addChild(leafB);
    22.         String result = root.operation();
    23.         System.out.println(result);
    24.     }
    26.     // 抽象节点
    27.     static abstract class Component {
    28.         protected String name;
    30.         public Component(String name) {
    31.             this.name = name;
    32.         }
    34.         public abstract String operation();
    36.         public boolean addChild(Component component) {
    37.             throw new UnsupportedOperationException("addChild not supported");
    38.         }
    40.         public boolean removeChild(Component component) {
    41.             // 直接抛异常而非抽象方法的原因：
    42.             // 使用了抽象方法，则子类必须实现，这样就体现不了各类子类的差异
    43.             // 而使用抛异常，则子类无需实现与本身功能无关的方法
    44.             throw new UnsupportedOperationException("removeChild not supported");
    45.         }
    47.         public Component getChild(int index) {
    48.             throw new UnsupportedOperationException("getChild not supported");
    49.         }
    50.     }
    52.     // 树枝节点
    53.     static class Composite extends Component {
    54.         private List<Component> components;
    56.         public Composite(String name) {
    57.             super(name);
    58.             this.components = new ArrayList<>();
    59.         }
    61.         @Override
    62.         public String operation() {
    63.             StringBuilder builder = new StringBuilder(this.name);
    64.             for (Component component : this.components) {
    65.                 builder.append("\n");
    66.                 builder.append(component.operation());
    67.             }
    68.             return builder.toString();
    69.         }
    71.         @Override
    72.         public boolean addChild(Component component) {
    73.             return components.add(component);
    74.         }
    76.         @Override
    77.         public boolean removeChild(Component component) {
    78.             return components.remove(component);
    79.         }
    81.         @Override
    82.         public Component getChild(int index) {
    83.             return components.get(index);
    84.         }
    85.     }
    87.     // 叶子节点
    88.     static class Leaf extends Component {
    89.         public Leaf(String name) {
    90.             super(name);
    91.         }
    93.         @Override
    94.         public String operation() {
    95.             return this.name;
    96.         }
    97.     }
    98. }