设计模式--组合模式

1. 组合模式：组合多个对象形成树形结构以表示"整体-部分"的结构层次。

2. 组合模式对单个对象(叶子对象)和组合对象(组合对象)具有一致性，它将对象组织到树结构中，可以用来描述整体与部分的关系。同时他也模糊了简单元素(叶子对象)和复杂元素(容器对象)的概念，使得客户能够像处理简单元素一样来处理复杂元素，即使客户程序与复杂元素的内部结构解耦。

3. 组合模式最关键的地方：叶子对象和组合对象实现相同的接口，这就是组合模式能够将叶子节点和对象节点进行一致处理的原因。

4. 组合模式的UML图

   

5. component对象声明接口，代表整体；Leaf代表部分，叶子对象；Composite容器对象，用来存储整体与部分的容器。

6. 组合模式的代码实现

   1. 创建一个component对象

      /**
       * component对象，抽象对象，最终的目的是管理抽象对象，代表了整体
       */
      public abstract class Game {
      
          String name;
      
          abstract void desplay();
      
          public Game() {
          }
      
          public Game(String name) {
              this.name = name;
          }
      
          public String getName() {
              return name;
          }
      
          public void setName(String name) {
              this.name = name;
          }
      }
      

   2. 创建三个叶子对象

      /**
       * 叶子对象,CS游戏，代表了部分
       */
      public class CSGame extends Game{
      
          public CSGame(String name) {
              super(name);
          }
      
          @Override
          void desplay() {
              System.out.println("这个游戏是：" + super.getName());
          }
      }
      

      /**
       * 叶子对象，dota游戏，代表了部分
       */
      public class DotaGame extends Game {
      
          public DotaGame(String name) {
              super(name);
          }
      
          @Override
          void desplay() {
              System.out.println("这个游戏是：" + super.getName());
          }
      
      }
      

      /**
       * 叶子对象，LOL游戏，代表了部分
       */
      public class LOLGame extends Game {
      
          public LOLGame(String name) {
              super(name);
          }
      
          @Override
          void desplay() {
              System.out.println("这个游戏是：" + super.getName());
          }
      }
      

   3. 创建一个容器对象

      import java.util.ArrayList;
      import java.util.List;
      
      /**
       * Composite对象，存储管理抽象对象，是一个容器
       * 继承Game,是为了对所有相关的对象(整体进和部分)进行完善管理
       */
      public class GameComposite extends Game {
      
          private List<Game> gameList;
      
          public GameComposite(String name) {
              super(name);
              gameList = new ArrayList<Game>();
          }
      
          /**
           * 游戏展示
           */
          @Override
          void desplay() {
              for (Game game : gameList){
                  game.desplay();
              }
          }
      
          public void addGame(Game game){
              gameList.add(game);
          }
      
          public void removeGame(Integer index){
              gameList.remove(index);
          }
      
      }
      

   4. 测试类

      public class Test {
      
          public static void main(String[] args) {
              GameComposite gameComposite = new GameComposite("总游戏");
      
              CSGame csGame = new CSGame("cs game");
      
              GameComposite gameComposite2 = new GameComposite("竞技游戏");
              DotaGame dotaGame = new DotaGame("dota game");
              LOLGame lolGame = new LOLGame("lol game");
      
              gameComposite2.addGame(dotaGame);
              gameComposite2.addGame(lolGame);
      
              gameComposite.addGame(csGame);          //对部分的管理
              gameComposite.addGame(gameComposite2);  //对整体的管理
      
              gameComposite.desplay();
              System.out.println("-----------------------------");
              gameComposite2.desplay();
          }
      }
      

7. 组合模式的优点

   1. 可以清楚的定义分层次的复杂对象，表示对象的全部或部分层次，使得增加新构建更加容易。
   2. 客户端简单调用，客户端可以一致的使用组合结构或其中单个对象。
   3. 定义了包含叶子对象和容器对象的类层次结构，叶子对象可以被组合成更加辅助的容器对象，而这个容器对象又可以被组合，不断的递归下去，就可以形成复杂的树形结构。
   4. 更容易在组合体内加入对象构件，客户端不必因为加入了新的对象构件而更改原有的代码。

8. 组合模式的缺点

   1. 使得设计更加抽象，对象业务规则如果很复杂，实现组合模式具有很大的挑战性，而且不是所有的方法都与叶子对象子类都有关联。

9. 组合模式的使用场景：

10. 需要表示一个对象整体或部分层次，在具有整体和部分的层次结构中，希望可以通过一种方式忽略整体与部分的差异，可以一致的对待它们。

11. 让客户能够忽略不同对象层次的变化，客户端可以针对抽象构建编程，无需关心对象层次结构的细节。

12. JDK中堆组合模式的使用