组合模式

定义：将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使对单个对象和组合对象保持一致的方式处理；
类型：结构型；

优点：

1. 清楚地定义分层次的复杂对象，表示对象的全部或部分层次；
2. 让客户端忽略了层次的差异，方便对整个层次结构进行控制；
3. 简化客户端代码；
4. 符合开闭原则；

缺点：

1. 限制类型时会较为复杂；
2. 使设计变得更抽象；

举例

// 目录组件
public abstract class CatalogComponent {
    public String getName(CatalogComponent catalogComponent){
        throw new UnsupportedOperationException("不支持获取名称操作");
    }

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

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

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

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

// 目录类
public class CourseCatalog extends CatalogComponent {
    private String name;
    private Integer level;
    List<CatalogComponent> items = new ArrayList<CatalogComponent>();

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

    @Override
    public String getName(CatalogComponent catalogComponent) {
        return name;
    }

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

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

    @Override
    public void print() {
        System.out.println(name);
        for (CatalogComponent item : items) {
            if (this.level != null){
                for (int i = 0; i < this.level; i++) {
                    System.out.print(" ");
                }
            }
            item.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(CatalogComponent catalogComponent) {
        return name;
    }

    @Override
    public double getPrice(CatalogComponent catalogComponent) {
        return price;
    }

    @Override
    public void print() {
        System.out.println("CourseName:"+name+" price:"+price);
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        CatalogComponent catalog1 = new CourseCatalog("主目录",1);
        CatalogComponent linuxCourse = new Course("linux课程",33);
        CatalogComponent windowCourse = new Course("window课程",44);

        CatalogComponent catalog2 = new CourseCatalog("java课程目录",2);
        CatalogComponent javaCourse = new Course("java课程",55);
        CatalogComponent designCourse = new Course("设计模式课程",66);

        catalog2.add(javaCourse);
        catalog2.add(designCourse);
        catalog1.add(linuxCourse);
        catalog1.add(windowCourse);
        catalog1.add(catalog2);

        catalog1.print();
    }
}

// 输出结果
主目录
  CourseName:linux课程 price:33.0
  CourseName:window课程 price:44.0
  java课程目录
    CourseName:java课程 price:55.0
    CourseName:设计模式课程 price:66.0

组合模式在jdk和mybatis中的应用

1. java.awt包下Conponent类的add方法

public Component add(Component comp){
    addImpl(comp, null, -1);
    return comp;
}

2. java.util包下的HashMap类的putAll方法

public void putAll(Map<? extends K, ? extends V> m) {
        putMapEntries(m, true);
}

3. java.util包下的ArrayLisy类的addAll方法

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

4.org.apache.ibatis.scripting.xmltags包下的SqlNode接口下的apply方法

public interface SqlNode{
    boolean apply(DynamicContext context);
}