设计模式十二之组合模式

  在现实生活中，存在很多“部分-整体”的关系，例如，大学中的部门与学院、总公司中的部门与分公司、学习用品中的书与书包、生活用品中的衣月艮与衣柜以及厨房中的锅碗瓢盆等。在软件开发中也是这样，例如，文件系统中的文件与文件夹、窗体程序中的简单控件与容器控件等。对这些简单对象与复合对象的处理，如果用组合模式来实现会很方便。

1. 模式的定义与特点

1.1 模式的定义

  组合模式（Composite）：有时又叫做“部分与整体模式“，是一种将对象整合成树状层次结构的模式，用来表示部分与整体的关系，使用户用单个对象和组合对象具有一致的访问性。

1.2 模式的特点

  组合模式的优点有：
    1. 使客户端代码可以一致地处理单个对象和组合对象，无需关系自己处理的是单个对象或是组合对象，简化了客户端代码；
    2. 更容易在组合体内加入新的对象，客户端不会因为加入新的对象而更改代码，满足开闭原则。

  组合模式的缺点有：
    1. 限制类型时较为复杂；
    2. 使设计变得更加抽象，客户端需要花更多的时间理清类之间的层次关系。

1.3 模式的使用场景

  1. 希望客户端可以忽略组合对象和单个对象的差异时；
  2. 处理一个树形结构时。

2. 模式的结构与实现

2.1 模式的结构

  组合模式的主要角色如下：
    1. 抽象构建角色（Component）：主要为树叶构建角色和树枝构建角色声明公共接口，并实现他们的默认行为，在透明式的组合模式中抽象构建还声明和管理子类的接口；在安全式的组合模式中抽象构建不声明和管理子类的接口，管理工作由树枝构建完成；
    2. 树枝构建角色（Composite）：是组合中的分支节点对象，它有子节点。它实现了抽象构建角色中声明的接口，主要作用是存储和管理子部件，通常包含 add() remove() getChild() 等方法。
    3. 树叶构建角色（Leaf）：是组合中的叶子节点对象，它没有子节点，实现了抽象构建中声明的接口。

  组合模式分为透明式的组合模式和安全式的组合模式：
    1. 透明方式：在该方式中，由于抽象构件声明了所有子类中的全部方法，所以客户端无须区别树叶对象和树枝对象，对客户端来说是透明的。但其缺点是：树叶构件本来没有 Add()、Remove() 及 GetChild() 方法，却要实现它们（空实现或抛异常），这样会带来一些安全性问题；

    2. 安全方式：在该方式中，将管理子构件的方法移到树枝构件中，抽象构件和树叶构件没有对子对象的管理方法，这样就避免了上一种方式的安全性问题，但由于叶子和分支有不同的接口，客户端在调用时要知道树叶对象和树枝对象的存在，所以失去了透明性。

2.2 模式的实现

抽象构建

/**
 * 抽象构建 - 目录组件
 */
public abstract class CatalogComponent {

    public void add(CatalogComponent catalogComponent) {
        throw new UnsupportedOperationException("不支持添加操作");
    }

    public void remove(CatalogComponent catalogComponent) {
        throw new UnsupportedOperationException("不支持删除操作");
    }

    public String getName() {
        throw new UnsupportedOperationException("不支持获取名称操作");
    }

    public Double getPrice() {
        throw new UnsupportedOperationException("不支持获取价格操作");
    }

    public void print() {
        throw new UnsupportedOperationException("不支持打印操作");
    }

}

树枝构建

/**
 * 树枝构建 - 课程目录
 */
public class CourseCatalog extends CatalogComponent {

    private String name;

    private Integer level;

    private List<CatalogComponent> items = new ArrayList<>();

    public CourseCatalog(String name, Integer level) {
        this.name = name;
        this.level = level;
    }

    @Override
    public void add(CatalogComponent catalogComponent) {
        items.add(catalogComponent);
    }

    @Override
    public void remove(CatalogComponent catalogComponent) {
        items.remove(catalogComponent);
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public void print() {
        System.out.println(this.name);
        for (CatalogComponent catalogComponent : items) {
            if (level != null) {
                for (int i=0; i<this.level; i++) {
                    System.out.print("  ");
                }
            }
            catalogComponent.print();
        }

    }
}

树叶构建

/**
 * 树叶构建 - 课程
 */
public class Course extends CatalogComponent {

    private String name;

    private Double price;

    public Course(String name, Double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public Double getPrice() {
        return this.price;
    }

    @Override
    public void print() {
        System.out.println("课程名称：" + this.name + ", 课程价格为：" + this.price);
    }
}

客户端

public class Client {

    public static void main(String[] args) {
        CatalogComponent root = new CourseCatalog("学习目录", 1);
        CatalogComponent python = new Course("python 课程", 11D);
        CatalogComponent lunix = new Course("lunix 课程", 66D);

        CatalogComponent javaCatalog = new CourseCatalog("Java 学习", 2);
        CatalogComponent web = new Course("web 基础", 33D);
        CatalogComponent redis = new Course("redis 基础", 44D);
        CatalogComponent java = new Course("java 基础", 54D);

        root.add(python);
        root.add(lunix);
        javaCatalog.add(web);
        javaCatalog.add(redis);
        javaCatalog.add(java);
        root.add(javaCatalog);

        root.print();
    }
}

# 运行结果如下：
学习目录
  课程名称：python 课程, 课程价格为：11.0
  课程名称：lunix 课程, 课程价格为：66.0
  Java 学习
    课程名称：web 基础, 课程价格为：33.0
    课程名称：redis 基础, 课程价格为：44.0
    课程名称：java 基础, 课程价格为：54.0

3. 模式在开源软件中的应用

3.1 java.util.HashMap 类

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
    public void putAll(Map<? extends K, ? extends V> m) {
        putMapEntries(m, true);
    }
}

3.2 java.util.ArrayList 类

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
            
    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }
}