目的

将对象组合成树形结构来表示“整体/部分”层次关系，允许用户以相同的方式处理单独对象和组合对象。

类图

组件（Component）类是组合类（Composite）和叶子类（Leaf）的父类，可以把组合类看成是树的中间节点。
组合对象拥有一个或者多个组件对象，因此组合对象的操作可以委托给组件对象去处理，而组件对象可以是另一个组合对象或者叶子对象。
组合类图.png

实现

  1. public abstract class Component {
  2.     protected String name;
  4.     public Component(String name) {
  5.         this.name = name;
  6.     }
  8.     public void print() {
  9.         print(0);
  10.     }
  12.     abstract void print(int level);
  14.     abstract public void add(Component component);
  16.     abstract public void remove(Component component);
  17. }
  20. public class Composite extends Component {
  22.     private List<Component> child;
  24.     public Composite(String name) {
  25.         super(name);
  26.         child = new ArrayList<>();
  27.     }
  29.     @Override
  30.     void print(int level) {
  31.         for (int i = 0; i < level; i++) {
  32.             System.out.print("--");
  33.         }
  34.         System.out.println("Composite:" + name);
  35.         for (Component component : child) {
  36.             component.print(level + 1);
  37.         }
  38.     }
  40.     @Override
  41.     public void add(Component component) {
  42.         child.add(component);
  43.     }
  45.     @Override
  46.     public void remove(Component component) {
  47.         child.remove(component);
  48.     }
  49. }
  52. public class Leaf extends Component {
  53.     public Leaf(String name) {
  54.         super(name);
  55.     }
  57.     @Override
  58.     void print(int level) {
  59.         for (int i = 0; i < level; i++) {
  60.             System.out.print("--");
  61.         }
  62.         System.out.println("left:" + name);
  63.     }
  65.     @Override
  66.     public void add(Component component) {
  67.         throw new UnsupportedOperationException(); // 牺牲透明性换取单一职责原则，这样就不用考虑是叶子节点还是组合节点
  68.     }
  70.     @Override
  71.     public void remove(Component component) {
  72.         throw new UnsupportedOperationException();
  73.     }
  74. }
  77. public class Client {
  78.     public static void main(String[] args) {
  79.         Composite root = new Composite("root");
  80.         Component node1 = new Leaf("1");
  81.         Component node2 = new Composite("2");
  82.         Component node3 = new Leaf("3");
  83.         root.add(node1);
  84.         root.add(node2);
  85.         root.add(node3);
  86.         Component node21 = new Leaf("21");
  87.         Component node22 = new Composite("22");
  88.         node2.add(node21);
  89.         node2.add(node22);
  90.         Component node221 = new Leaf("221");
  91.         node22.add(node221);
  92.         root.print();
  93.     }
  94. }
  97. 运行结果
  98. Composite:root
  99. --left:1
  100. --Composite:2
  101. ----left:21
  102. ----Composite:22
  103. ------left:221
  104. --left:3

JDK中的体现

  • javax.swing.JComponent#add(Component)
  • java.awt.Container#add(Component)
  • java.util.Map#putAll(Map)
  • java.util.List#addAll(Collection)
  • java.util.Set#addAll(Collection)