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

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

组合模式-树形结构的处理_第1张图片

图 A公司部分组织架构图

图 传统解决方案

public class Development {

    private String name;

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

    List employeeList = new ArrayList<>();
    List 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)。

组合模式-树形结构的处理_第2张图片

图 组合模式结构图

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 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();
    }
}

1.1 透明组合模式

抽象构件中声明了所有用于管理成员对象的方法,包括addChildren()、removeChildren等。

优点:确保所有构件类都有相同的接口。在客户端看来,叶子对象与容器所提供的方法是一致的,客户端可以相同地对待所有对象。

缺点:不够安全,叶子对象和容器对象在本质上是有区别的,叶子对象不可能有下一层级的对象,即提供管理成员对象的方法是没有任何意义的。如果在运行阶段调用了这些方法,可能会出错。

透明组合模式是组合模式标准形式。

1.2 安全组合模式

抽象构件中没有声明任何用于管理成员对象的方法,而是在容器构件Composite类中声明并实现了这些方法。

优点:安全,客户端不可能会调用到叶子阶段的管理成员对象的方法。

缺点:不够透明,客户端不能完全针对抽象编程,必须有区别地对待叶子构件和容器构件。

2 优缺点

优点:

  1. 可以清楚地定义分层次的复杂对象,表示对象全部或部分层次,让客户端忽略了层次的差异,方便对整个层次结构进行控制。
  2. 增加新的容器构件和叶子构件都很方便,无须对现有类库进行任何修改,符合开闭原则。

缺点:

  1. 在增加新构件时很难对容器中的构件类型进行限制。当希望一个容器只能有某些特定类型对象时,因为它们都来自相同的抽象层,在这种情况下,必须通过在运行时进行类型检查来实现,这个过程较为复杂。

3 适用场景

  1. 在具有整体和部分的层次结构中,希望通过一种方式忽略整体与部分的差异,客户端可以一致性对待它们。
  2. 一个系统中能够分离出叶子对象和容器对象,而且它们的类型不固定,将来需要增加一些新的类型。

你可能感兴趣的:(设计模式的艺术,组合模式)