组合模式-树形结构的处理

A公司需要筛选出年龄35岁及以上(如果是领导，年龄为45岁及以上)的人。其组织架构图如下。

图 A公司部分组织架构图

图传统解决方案

public class Development {

    private String name;

    public Development(String name) {
        this.name = name;
    }

    List<Employee> employeeList = new ArrayList<>();
    List<Development> developmentList = new ArrayList<>();

    public void find() {
        for (Employee employee : employeeList) {
            employee.find();
        }
        for (Development development : developmentList) {
            development.find();
        }
    }

    public String getName() {
        return name;
    }
}

public class Employee {

    private Development development;

    private String name;
    private Integer age;
    private Boolean isLead;

    public Employee(Development development,String name, Integer age, Boolean isLead) {
        this.development = development;
        this.name = name;
        this.age = age;
        this.isLead = isLead;
    }

    public void find() {
        if ((!isLead && age >= 35) || (isLead && age >= 45)) {
            System.out.println(development.getName() + ":" + name + "超龄：" + age + " " + (isLead ? "是" : "不是") + "领导");
        }
    }

}

public class Client {

    Development development = new Development("董事会");

    {
        development.employeeList.add(new Employee(development,"黄总", 53,true));

        development.developmentList.add(new Development("行政部"));
        development.developmentList.add(new Development("营销部"));
        Development techDev = new Development("技术部门");
        development.developmentList.add(techDev);

        techDev.employeeList.add(new Employee(techDev,"技术部经理",36,true));
        techDev.developmentList.add(new Development("技术A组"));
        techDev.developmentList.add(new Development("技术C组"));
        Development bDev = new Development("技术B组");
        techDev.developmentList.add(bDev);

        bDev.employeeList.add(new Employee(bDev,"小黄",27,false));
        bDev.employeeList.add(new Employee(bDev,"小张",27,false));
        bDev.employeeList.add(new Employee(bDev,"老刘",35,false));
    }

    public static void main(String[] args) {
        Client client = new Client();
        client.development.find();
//        运行结果：
//        董事会:黄总超龄：53 是领导
//        技术B组:老刘超龄：35 不是领导
    }

}

在上图的架构图中，同一层存在员工及部门两类实体，它们都有个查找的方法。在代码中在成员变量中将这两类分别存储在两个不同容器中，在查找方法中，也分别对这两个类别调用了查找方法。代码有些冗余。

我们可以把同一层的员工及部门看作是同一类，这样我们只需要一个容器及查找方法也是只要在一处调用该方法了。这就是组合模式。

1 组合模式概述

由于容器对象和叶子对象在功能上的区别，在使用这些对象的代码中，必须有区别地对待容器对象和叶子对象，而实际上大多数情况下希望一致地处理它们，因为区别对待这些对象将会使得程序变得复杂。

组合模式为解决此类问题而诞生，可以让叶子对象和容器对象的使用具有一致性。

组合多个对象形成树形结构以表示具有”部分—整体“关系的层次结构。组合模式对单个对象（即叶子对象）和组合对象（即容器对象）的使用具有一致性，有被称为”部分—整体“模式（Part-Whole）。

图组合模式结构图

Component:抽象构件，可以是接口或抽象类。可以包含所有子类共同行为的声名和实现。定义了访问及管理它的子构建的方法，例如增加、删除、获取子构件。

Leaf: 叶子构件，没有子节点,对于那些访问及管理子构件的方法，可以通过捕获异常等方式进行处理。

Composite: 容器构件，表示容器对象，包含了子节点。子节点可以是叶子节点，也可以是容器节点。

public interface Component {

    void find(); //查找超龄员工

    void addChildren(Component component);

    void removeChildren(Component component);

    Component getChildren(int pos);

}

public class Development implements Component{

    private String name;

    public Development(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    private final List<Component> componentList = new ArrayList<>();

    @Override
    public void find() {
        for (Component component : componentList) component.find();;
    }

    @Override
    public void addChildren(Component component) {
       componentList.add(component);
    }

    @Override
    public void removeChildren(Component component) {
        componentList.remove(component);
    }

    @Override
    public Component getChildren(int pos) {
        return componentList.get(pos);
    }
}

public class Employee implements Component{

    private String name;
    private Integer age;
    private Boolean isLead;

    public Employee(String name, Integer age, Boolean isLead) {
        this.name = name;
        this.age = age;
        this.isLead = isLead;
    }

    @Override
    public void find() {
        if ((!isLead && age >= 35) || (isLead && age >= 45)) {
            System.out.println(name + "超龄：" + age + " " + (isLead ? "是" : "不是") + "领导");
        }
    }

    @Override
    public void addChildren(Component component) {
        throw new RuntimeException("该方法不可用");
    }

    @Override
    public void removeChildren(Component component) {
        throw new RuntimeException("该方法不可用");
    }

    @Override
    public Component getChildren(int pos) {
        throw new RuntimeException("该方法不可用");
    }

}

public class Client {

    private static final Component component = new Development("董事会");

    static {
        component.addChildren(new Employee("黄总", 53,true));

        component.addChildren(new Development("行政部"));
        component.addChildren(new Development("营销部"));
        Component techCom = new Development("技术部");
        component.addChildren(techCom);

        techCom.addChildren(new Employee("技术部经理",36,true));
        techCom.addChildren(new Development("技术A组"));
        techCom.addChildren(new Development("技术C组"));
        Component bDev = new Development("技术B组");
        techCom.addChildren(bDev);

        bDev.addChildren(new Employee("小黄",27,false));
        bDev.addChildren(new Employee("小张",27,false));
        bDev.addChildren(new Employee("老刘",35,false));
    }

    public static void main(String[] args) {
        component.find();
    }
}