1. 写在前面

上一小节中，我们认识了桥接（Bridge），其适用于类在两个维度变化的情景，将两个维度独立封装，并且第二个维度中持有第一个维度的实例对象，最终达到两个维度都灵活变化的场景，避免了子类爆炸。

2. 组合模式 Composite Pattern

本篇参考了 菜鸟教程-组合模式。
这里我们需要清楚几个点：

• 解决问题：通过树形结构，将对象表示成 “部分-整体” 的结构，使得用户使用的时候对于 部分&整体 毫无差别。

3. 使用

• 场景：想要表示对象的树形结构，部分和整体 无差别使用。例如 文件夹 结构

• 核心：通过一个 List 持有 子节点，在节点内部实现业务逻辑

3.1 代码

/**
 * 满足 组合模式 的Employee类
 *
 * @author mikeshine
 * @date 2022-04-07
 */

public class EmployeeForComposite {
    /**
     * 名字
     */
    private String name;

    /**
     * 薪资
     */
    private Integer salary;

    /**
     * 部门
     */
    private String dept;

    /**
     * 下属的对象
     */
    private List<EmployeeForComposite> subordinates;

    public EmployeeForComposite(String name, Integer salary, String dept){
        this.name = name;
        this.salary = salary;
        this.dept = dept;
    }

    public void add(EmployeeForComposite employee){
        subordinates.add(employee);
    }

    public void remove(EmployeeForComposite employee){
        subordinates.remove(employee);
    }

    public List<EmployeeForComposite> getSubordinates(){
        return subordinates;
    }

    @Override
    public String toString() {
        return ("Employee :[ Name : "+ name
            +", dept : "+ dept + ", salary :"
            + salary+" ]");
    }
}

下面看一下如何调用，就更加清晰了

public class CompositePatternDemo {
   public static void main(String[] args) {
      Employee CEO = new Employee("John","CEO", 30000);
 
      Employee headSales = new Employee("Robert","Head Sales", 20000);
 
      Employee headMarketing = new Employee("Michel","Head Marketing", 20000);
 
      Employee clerk1 = new Employee("Laura","Marketing", 10000);
      Employee clerk2 = new Employee("Bob","Marketing", 10000);
 
      Employee salesExecutive1 = new Employee("Richard","Sales", 10000);
      Employee salesExecutive2 = new Employee("Rob","Sales", 10000);
 
      CEO.add(headSales);
      CEO.add(headMarketing);
 
      headSales.add(salesExecutive1);
      headSales.add(salesExecutive2);
 
      headMarketing.add(clerk1);
      headMarketing.add(clerk2);
 
      //打印该组织的所有员工
      System.out.println(CEO); 
      for (Employee headEmployee : CEO.getSubordinates()) {
         System.out.println(headEmployee);
         for (Employee employee : headEmployee.getSubordinates()) {
            System.out.println(employee);
         }
      }        
   }
}

可以看到，这里多级对象之间的处理方式都是一致的，但是同时可以通过内部的 List 保留级别信息，体现出一定的差异性。