组合(Composite)

Intent

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

Class Diagram

组件(Component)类是组合类(Composite)和叶子类(Leaf)的父类,可以把组合类看成是树的中间节点。

组合对象拥有一个或者多个组件对象,因此组合对象的操作可以委托给组件对象去处理,而组件对象可以是另一个组合对象或者叶子对象。

设计模式 - 组合 - 图1

Implementation

  1. public abstract class Component {
  2. protected String name;
  3. public Component(String name) {
  4. this.name = name;
  5. }
  6. public void print() {
  7. print(0);
  8. }
  9. abstract void print(int level);
  10. abstract public void add(Component component);
  11. abstract public void remove(Component component);
  12. }
  1. public class Composite extends Component {
  2. private List<Component> child;
  3. public Composite(String name) {
  4. super(name);
  5. child = new ArrayList<>();
  6. }
  7. @Override
  8. void print(int level) {
  9. for (int i = 0; i < level; i++) {
  10. System.out.print("--");
  11. }
  12. System.out.println("Composite:" + name);
  13. for (Component component : child) {
  14. component.print(level + 1);
  15. }
  16. }
  17. @Override
  18. public void add(Component component) {
  19. child.add(component);
  20. }
  21. @Override
  22. public void remove(Component component) {
  23. child.remove(component);
  24. }
  25. }
  1. public class Leaf extends Component {
  2. public Leaf(String name) {
  3. super(name);
  4. }
  5. @Override
  6. void print(int level) {
  7. for (int i = 0; i < level; i++) {
  8. System.out.print("--");
  9. }
  10. System.out.println("left:" + name);
  11. }
  12. @Override
  13. public void add(Component component) {
  14. throw new UnsupportedOperationException(); // 牺牲透明性换取单一职责原则,这样就不用考虑是叶子节点还是组合节点
  15. }
  16. @Override
  17. public void remove(Component component) {
  18. throw new UnsupportedOperationException();
  19. }
  20. }
  1. public class Client {
  2. public static void main(String[] args) {
  3. Composite root = new Composite("root");
  4. Component node1 = new Leaf("1");
  5. Component node2 = new Composite("2");
  6. Component node3 = new Leaf("3");
  7. root.add(node1);
  8. root.add(node2);
  9. root.add(node3);
  10. Component node21 = new Leaf("21");
  11. Component node22 = new Composite("22");
  12. node2.add(node21);
  13. node2.add(node22);
  14. Component node221 = new Leaf("221");
  15. node22.add(node221);
  16. root.print();
  17. }
  18. }
  1. Composite:root
  2. --left:1
  3. --Composite:2
  4. ----left:21
  5. ----Composite:22
  6. ------left:221
  7. --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)

设计模式 - 组合 - 图2