23种设计模式【Java】解析 - 组合模式

组合模式

目的

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

类图

1. Component ：抽象构件类。定义参加组合对象的共有方法和属性，可以定义一些默认的行为或属性。
2. Leaf ：叶子对象。没有子结点。
3. Composite：容器（树枝）构件。包含子节点，子节点可以是叶子节点，也可以是容器节点，提供一个集合用于存储子节点，

实现

抽象构建类

public abstract class Component {
    protected String name;

    public Component(String name) {
        this.name = name;
    }

    public void print() {
        print(0);
    }

    abstract void print(int level);

    abstract public void add(Component component);

    abstract public void remove(Component component);
}
  

容器构件

public class Composite extends Component {

    private List<Component> child;

    public Composite(String name) {
        super(name);
        child = new ArrayList<>();
    }

    @Override
    void print(int level) {
        for (int i = 0; i < level; i++) {
            System.out.print("--");
        }
        System.out.println("Composite:" + name);
        for (Component component : child) {
            component.print(level + 1);
        }
    }

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

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

叶子节点

public class Leaf extends Component {
    public Leaf(String name) {
        super(name);
    }

    @Override
    void print(int level) {
        for (int i = 0; i < level; i++) {
            System.out.print("--");
        }
        System.out.println("left:" + name);
    }

    @Override
    public void add(Component component) {
        throw new UnsupportedOperationException(); // 牺牲透明性换取单一职责原则，这样就不用考虑是叶子节点还是组合节点
    }

    @Override
    public void remove(Component component) {
        throw new UnsupportedOperationException();
    }
}
  

调用类

public class Client {
    public static void main(String[] args) {
        Composite root = new Composite("root");
        Component node1 = new Leaf("1");
        Component node2 = new Composite("2");
        root.add(node1);
        root.add(node2);
        // 容器构件可以拥有子节点
        Component node21 = new Leaf("21");
        Component node22 = new Composite("22");
        node2.add(node21);
        node2.add(node22);
        Component node221 = new Leaf("221");
        node22.add(node221);
        root.print();
    }
}

优缺点

1. 优点

• 高层模块调用简单。高层模块不必关心自己处理的是单个对象还是整个组合结构，简化了高层模块的代码。
• 节点自由增加。非常容易扩展，符合开闭原则，对以后的维护非常有利。

2. 缺点

• 树枝树叶直接使用了实现类，这在面向接口编程上是很不恰当的，与依赖倒置原则冲突，限制了接口的影响范围。

使用场景

• 需要表示一个对象整体或部分层次，希望通过一种方式忽略整体与部分的差异，一致对待它们。
• 让客户能忽略不同对象层次的变化，客户端可以针对抽象构件编程，无须关心对象层次结构的细节。

使用

• 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)