结构类模式（三）：组合（Composite）

定义

将对象组合成树形结构以表示“部分整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

有时候又叫做部分-整体模式，它使我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以像处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。

比较常见的有文件系统：文件系统由目录和文件组成。每个目录都可以装内容。目录的内容可以是文件，也可以是目录。按照这种方式，计算机的文件系统就是以递归结构来组织的。如果你想要描述这样的数据结构，那么你可以使用组合模式。

另外如果使用过Flash，会知道Flash所使用的显示列表就是一个树形结构，每个显示容器都可以包含任意多的显示对象，而显示对象又可以是显示容器。

UML

优点

1. 使客户端调用简单，客户端可以一致的使用组合结构或其中单个对象，用户就不必关心自己处理的是单个对象还是整个组合结构，这就简化了客户端代码。
2. 更容易在组合体内加入对象部件. 客户端不必因为加入了新的对象部件而更改代码。这一点符合开闭原则的要求，对系统的二次开发和功能扩展很有利。

缺点

1. 组合模式不容易限制组合中的构件。

应用场景

1. 当你发现需求中是体现部分与整体层次的结构时，以及你希望可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象时，就应该考虑使用组合模式了。
2. 你想表示对象的部分-整体层次结构。
3. 你希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。

示例

使用组合模式构建一个树形结构。

Java

 import java.util.ArrayList;
 import java.util.List;

 public class Main
 {
     public static void main(String[] args)
     {
         try
         {
             //所有结点都使用基类类型定义
             Component root = new Composite();

             Component c1 = new Composite();
             Component c2 = new Composite();

             Component leaf1 = new Leaf();
             Component leaf2 = new Leaf();
             Component leaf3 = new Leaf();

             //添加到树形结构上
             root.addChild(c1);
             root.addChild(leaf1);

             c1.addChild(leaf2);
             c1.addChild(c2);

             c2.addChild(leaf3);

             //执行指定的一个叶子结点
             root.getChildAt(0).getChildAt(1).getChildAt(0).doSomething();
         }
         catch (Exception e)
         {
             e.printStackTrace();
         }
     }

     /**
      * 组合组件的基类, 所有树形结构上的结点都必须继承自该类
      */
     public static abstract class Component
     {
         public abstract void addChild(Component child) throws Exception;
         public abstract Component getChildAt(int index) throws Exception;
         public abstract void removeChild(Component child) throws Exception;
         public abstract void doSomething();
     }

     /**
      * 容器类
      */
     public static class Composite extends Component
     {
         private List<Component> _children;

         public Composite()
         {
             _children = new ArrayList<>();
         }

         @Override
         public void addChild(Component child)
         {
             _children.add(child);
         }

         @Override
         public Component getChildAt(int index)
         {
             return _children.get(index);
         }

         @Override
         public void removeChild(Component child)
         {
             _children.remove(child);
         }

         @Override
         public void doSomething()
         {
             System.out.println("容器对象处理了某个事务");
         }
     }

     /**
      * 叶子类
      */
     public static class Leaf extends Component
     {
         @Override
         public void addChild(Component child) throws Exception
         {
             throw new Exception("叶子对象不能添加子对象");
         }

         @Override
         public Component getChildAt(int index) throws Exception
         {
             throw new Exception("叶子对象不能获取子对象");
         }

         @Override
         public void removeChild(Component child) throws Exception
         {
             throw new Exception("叶子对象不能移除子对象");
         }

         @Override
         public void doSomething()
         {
             System.out.println("叶子对象处理了某个事务");
         }
     }
 }