组合模式

2021-09-10

一、概述

组合模式让叶子对象和容器对象的使用具有一致性。

组合模式的定义为：组合多个对象形成树形结构以表示具有“整体–部分”关系的层次结构。组合模式对叶子对象和容器对象的使用具有一致性，又称为“整体–部分”模式，它是一种对象结构型模式。

透明组合模式结构图如图所示：

安全组合模式结构图如图所示：

组合模式的关键是定义了一个抽象构件类，它既可以代表叶子，又可以代表容器，而客户端针对该抽象构件类进行编程，无须知道它到底表示的是叶子还是容器，可以对其进行统一处理。同时容器对象与抽象构件类之间还建立一个聚合关联关系，在容器对象中既可以包含叶子，也可以包含容器，以此实现递归组合，形成一个树形结构。

二、示例代码

组合模式中包含抽象构件类(Component)、叶子构件类(Leaf)以及容器构件类(Composite)。

抽象构件类(Component)典型代码如下：

public abstract class Component {
  public abstract void add(Component c); //增加成员
  public abstract void remove(Component c); //删除成员
  public abstract Component getChild(int i); //获取成员
  public abstract void operation(); //业务方法
}

如果继承的是叶子构件类(Leaf)，典型代码如下：

public class Leaf extends Component {
  public void add(Component c) {
    //异常处理或错误提示
  }
  public void remove(Component c) {
    //异常处理或错误提示
  }
  public Component getChild(int i) {
    //异常处理或错误提示
    return null;
  }
  public void operation() {
    //叶子构件具体业务方法的实现
  }
}

如果继承的是容器构件(Composite)，典型代码如下：

public class Composite extends Component {
  private ArrayList<Component> list = new ArrayList<>();
  
  public void add(Component c) {
    list.add(c);
  }
  
  public void remove(Component c) {
    list.remove(c);
  }
  
  public Component getChild(int i) {
    return (Component)list.get(i);
  }
  
  public void operation() {
    for (Object obj:list) {
      ((Component)obj).operation();
    }
  }
}

三、demo

盘子装水果的选择，盘子里可以再叠盘子。

抽象构件类(Component)代码如下：

public interface MyElement {

    void eat();

}

叶子构件类(Leaf)代码如下：

public class Pear implements MyElement{
    @Override
    public void eat() {
        System.out.println("吃梨子！");
    }
}

public class Banana implements MyElement{
    @Override
    public void eat() {
        System.out.println("吃香蕉！");
    }
}

public class Apple implements MyElement{
    @Override
    public void eat() {
        System.out.println("吃苹果！");
    }
}

容器构件类(Composite)设计如下：

public class Plate implements MyElement{

    private ArrayList<MyElement> myElements = new ArrayList<>();

    public void add(MyElement element) {
        myElements.add(element);
    }

    public void delete(MyElement element) {
        myElements.remove(element);
    }

    @Override
    public void eat() {
        for (MyElement element : myElements) {
            element.eat();
        }
    }
}

客户端调用如下：

public static void main(String args[]) {
  MyElement obj1,obj2,obj3,obj4,obj5;
  Plate plate1,plate2,plate3;

  obj1 = new Apple();
  obj2 = new Pear();
  plate1 = new Plate();
  plate1.add(obj1);
  plate1.add(obj2);

  obj3 = new Banana();
  obj4 = new Banana();
  plate2 = new Plate();
  plate2.add(obj3);
  plate2.add(obj4);

  obj5 = new Apple();
  plate3 = new Plate();
  plate3.add(plate1);
  plate3.add(plate2);
  plate3.add(obj5);

  plate1.eat();
  System.out.println("--------");
  plate2.eat();
  System.out.println("--------");
  plate3.eat();
  System.out.println("--------");
}

代码运行结果：

四、总结

1. 优点

组合模式可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽略了层次的差异，方便对整个层次结构进行控制。
客户端可以一致地使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合结构，简化了客户端代码。
在组合模式中增加新的容器构件和叶子构件都很方便，无须对现有类库进行任何修改，符合“开闭原则”。
组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子对象和容器对象的递归组合，可以形成复杂的树形结构，但对树形结构的控制却非常简单。

2. 缺点

在增加新构件时很难对容器中的构件类型进行限制。有时候我们希望一个容器中只能有某些特定类型的对象，例如在某个文件夹中只能包含文本文件，使用组合模式时，不能依赖类型系统来施加这些约束，因为它们都来自于相同的抽象层，在这种情况下，必须通过在运行时进行类型检查来实现，这个实现过程较为复杂。

3. 适用场景

在具有整体和部分的层次结构中，希望通过一种方式忽略整体与部分的差异，客户端可以一致地对待它们。
在一个使用面向对象语言开发的系统中需要处理一个树形结构。
在一个系统中能够分离出叶子对象和容器对象，而且它们的类型不固定，需要增加一些新的类型。