介绍

Composite模式 组合模式

结构型模式之一（构造型模式之一）

通过递归手段来构造树形的对象结构，并可通过一个对象来访问整个对象树

应用场景

• 父类和子类有相同数据结构定义的场景

结构

角色与职责

• Component 树形结构的节点抽象
  • 为所有的对象定义统一的接口
  • 提供管理子节点对象的接口方法
  • [可选]提供管理父节点对象的接口方法
• Leaf 树形结构的叶节点
  • Component的实现子类
• Composite 属性结构的枝节点
  • Component的实现子类

代码实现

• Component

  import java.util.List;
  
  /**
   * 角色：Component 文件节点的抽象
   */
  public interface IFile {
  
      // 显示文件名称
      void display();
      // 添加
      boolean add(IFile file);
      // 移除
      boolean remove(IFile file);
      // 获得子节点
      List<IFile> getChild();
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

• Composite

  import java.util.ArrayList;
  import java.util.List;
  
  /**
   * 角色：Composite  文件夹
   */
  public class Folder implements IFile{
  
      private String name;
      private List<IFile> children;
  
      public Folder(String name) {
          this.name = name;
          this.children = new ArrayList<>();
      }
  
      @Override
      public void display() {
          System.out.println(name);
      }
  
      @Override
      public boolean add(IFile file) {
          return this.children.add(file);
      }
  
      @Override
      public boolean remove(IFile file) {
          return this.children.remove(file);
      }
  
      @Override
      public List<IFile> getChild() {
          return this.children;
      }
  
  
  }
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39

• Leaf

  import java.util.List;
  
  /**
   * 角色: leaf 文件
   * 分为透明形式和安全形式
   * 透明形式：所有的方法都实现
   * 安全形式：leaf关心的方法才实现（父类接口只定义公共的方法，leaf不关心的方法，在IFile接口也不定义）
   *
   * 这里使用透明形式
   */
  public class File implements IFile{
  
      private String name;
  
      public File(String name) {
          this.name = name;
      }
  
      @Override
      public void display() {
          System.out.println(name);
      }
  
      @Override
      public boolean add(IFile file) {
          return false;
      }
  
      @Override
      public boolean remove(IFile file) {
          return false;
      }
  
      @Override
      public List<IFile> getChild() {
          return null;
      }
  
  }
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40

• 测试

  import java.util.List;
  
  /**
   * 测试
   */
  public class ClientTest {
  
      public static void main(String[] args) {
          // C盘目录
          Folder rootFolder = new Folder("c:");
          // my目录
          Folder myFolder = new Folder("my");
          // my目录
          File textFile = new File("test.txt");
  
          rootFolder.add(myFolder);
          rootFolder.add(textFile);
  
          // 递归的
          displayTree(rootFolder);
  
      }
  
      private static void displayTree(IFile rootFolder) {
          // 显示自身名称
          rootFolder.display();
          // 获得子树
          List<IFile> child = rootFolder.getChild();
          // 遍历子树
          for (IFile iFile : child) {
              if(iFile instanceof File){
                  iFile.display();
              } else if(iFile instanceof Folder){
                  displayTree(iFile);
              }
          }
      }
  
  }
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40

• 输出

  c:
  my
  test.txt
  1
  2
  3