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

    一颗树一般有三种节点

    • 根节点
    • 树干节点
    • 叶子节点

    根节点和树干节点本质上是一种数据类型。在组合模式中，把树干节点和叶子节点也视为是一种数据类型(实现同一个接口)，在调用的时候不需要区分是树干节点还是叶子节点。
    当子系统与其内各个对象层次呈树形结构时，可以使用组合模式让子系统内各个对象层次的行为操作具备一致性。当客户端使用该子系统内任意一个对象时，不用进行区分，直接使用通用操作即可，非常便捷。

    场景：

    • 树状结构
    • 客户端可以忽略组合对象与单个对象的差异

    树枝节点和叶子节点实现用一个接口或继承同一个基类

    透明模式
    Component中声明树干节点和根节点的方法，具体实现由子类重写，客户端无需区分树干节点和叶子节点
    安全模式
    Component中只声明公共的方法，子类各自声明自己的特有方法
    接口定义职责分明，符合单一职责原则和接口隔离原则，但是客户端必须区分树干节点和叶子节点有些操作需要强制类型转换违背了依赖倒置原则
    当系统绝大多数层次都具备想用的公共行为，使用透明模式，当各个层次差异较多或树枝节点层级相对稳定时使用安全模式

    框架
    HashMap的putAll
    Mybatis的sqlNode

    安全模式的demo

    1. package com.company.composite;
    3. public abstract class Component {
    5.     protected String name;
    7.     public Component(String name) {
    8.         this.name = name;
    9.     }
    11.     public abstract void op();
    13. }
    14. package com.company.composite;
    16. import java.util.ArrayList;
    17. import java.util.List;
    19. public class Composite extends Component {
    21.     private List<Component> componentList;
    24.     public Composite(String name) {
    25.         super(name);
    26.         this.componentList = new ArrayList<>();
    27.     }
    29.     @Override
    30.     public void op() {
    31.         for(Component component : componentList){
    32.             component.op();
    33.         }
    34.     }
    36.     public void add(Component component){
    37.         this.componentList.add(component);
    38.     }
    40.     public void remove(Component component){
    41.         this.componentList.remove(component);
    42.     }
    44.     public void getChild(int index){
    45.         this.componentList.get(index);
    46.     }
    47. }
    48. package com.company.composite;
    50. public class Leaf extends Component {
    52.     public Leaf(String name) {
    53.         super(name);
    54.     }
    56.     @Override
    57.     public void op() {
    58.         System.out.println(this.name);
    59.     }
    60. }

    抽象模式的demo

    1. package com.company.composite;
    3. public abstract class Component {
    5.     protected String name;
    7.     public Component(String name) {
    8.         this.name = name;
    9.     }
    11.     public void add(Component component){
    12.          throw new UnsupportedOperationException();
    13.     }
    15.     public void remove(Component component){
    16.           throw new UnsupportedOperationException();
    17.     }
    19.     public void getChild(int index){
    20.           throw new UnsupportedOperationException();
    21.     }
    23. }
    24. package com.company.composite;
    26. import java.util.ArrayList;
    27. import java.util.List;
    29. public class Composite extends Component {
    31.     private List<Component> componentList;
    34.     public Composite(String name) {
    35.         super(name);
    36.         this.componentList = new ArrayList<>();
    37.     }
    39.     @Override
    40.     public void op() {
    41.         for(Component component : componentList){
    42.             component.op();
    43.         }
    44.     }
    45.     @Override
    46.     public void add(Component component){
    47.         this.componentList.add(component);
    48.     }
    49.     @Override
    50.     public void remove(Component component){
    51.         this.componentList.remove(component);
    52.     }
    53.     @Override
    54.     public void getChild(int index){
    55.         this.componentList.get(index);
    56.     }
    57. }
    58. package com.company.composite;
    60. public class Leaf extends Component {
    62.     public Leaf(String name) {
    63.         super(name);
    64.     }
    66.     @Override
    67.     public void op() {
    68.         System.out.println(this.name);
    69.     }
    70. }