组合模式(Composite Pattern)
组合模式(Composite Pattern)是一种结构型设计模式,它将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
组合模式的应用场景
- 需要表示对象的部分-整体层次结构:如文件系统中的目录和文件,图形系统中的图形和组合图形。
- 希望用户忽略组合对象与单个对象的不同,统一地使用组合结构中的所有对象:如菜单和菜单项的处理。
- 需要对树形结构中的节点和叶子节点进行相同的操作:如组织结构图中的部门和员工。
组合模式的实现方式
1. 透明组合模式
思想:通过定义一个抽象的组件类,所有的叶子节点和组合节点都继承自该组件类,使得客户端可以一致地处理叶子节点和组合节点。
实现方式:
import java.util.ArrayList;
import java.util.List;
// 抽象组件类
abstract class Component {
public void add(Component component) {
throw new UnsupportedOperationException();
}
public void remove(Component component) {
throw new UnsupportedOperationException();
}
public Component getChild(int i) {
throw new UnsupportedOperationException();
}
public abstract void operation();
}
// 叶子节点
class Leaf extends Component {
private String name;
public Leaf(String name) {
this.name = name;
}
public void operation() {
System.out.println("Leaf " + name + " is visited");
}
}
// 组合节点
class Composite extends Component {
private List<Component> children = new ArrayList<>();
public void add(Component component) {
children.add(component);
}
public void remove(Component component) {
children.remove(component);
}
public Component getChild(int i) {
return children.get(i);
}
public void operation() {
for (Component child : children) {
child.operation();
}
}
}
// 客户端代码
public class CompositePattern {
public static void main(String[] args) {
Component root = new Composite();
Component leaf1 = new Leaf("1");
Component leaf2 = new Leaf("2");
root.add(leaf1);
root.add(leaf2);
Component subComposite = new Composite();
Component leaf3 = new Leaf("3");
subComposite.add(leaf3);
root.add(subComposite);
root.operation();
}
}
优点:
- 定义了包含基本对象和组合对象的类层次结构,使得客户端可以一致地使用这些对象。
- 组合结构可以任意扩展,符合开闭原则。
- 简化客户端代码,使得客户端可以一致地处理叶子节点和组合节点。
缺点:
- 使得叶子节点和组合节点的接口变得复杂,因为对于叶子节点来说,某些方法是没有意义的(如
add
和remove
方法)。
2. 安全组合模式
思想:通过将子节点操作(如add
和remove
方法)放在组合节点中,而不是抽象组件类中,使得叶子节点的接口更加简洁。
实现方式:
import java.util.ArrayList;
import java.util.List;
// 抽象组件类
abstract class Component {
public abstract void operation();
}
// 叶子节点
class Leaf extends Component {
private String name;
public Leaf(String name) {
this.name = name;
}
public void operation() {
System.out.println("Leaf " + name + " is visited");
}
}
// 组合节点
class Composite extends Component {
private List<Component> children = new ArrayList<>();
public void add(Component component) {
children.add(component);
}
public void remove(Component component) {
children.remove(component);
}
public Component getChild(int i) {
return children.get(i);
}
public void operation() {
for (Component child : children) {
child.operation();
}
}
}
// 客户端代码
public class SafeCompositePattern {
public static void main(String[] args) {
Composite root = new Composite();
Component leaf1 = new Leaf("1");
Component leaf2 = new Leaf("2");
root.add(leaf1);
root.add(leaf2);
Composite subComposite = new Composite();
Component leaf3 = new Leaf("3");
subComposite.add(leaf3);
root.add(subComposite);
root.operation();
}
}
优点:
- 使得叶子节点的接口更加简洁,不需要实现组合节点特有的方法。
- 客户端只能通过组合节点来操作子节点,避免了叶子节点和组合节点的混淆。
缺点:
- 需要在客户端中区分叶子节点和组合节点,增加了客户端代码的复杂性。
- 不能保证客户端一致地处理叶子节点和组合节点,可能会导致操作上的不一致。
总结
实现方式 | 优点 | 缺点 |
---|---|---|
透明组合模式 | 客户端可以一致地处理叶子节点和组合节点,简化客户端代码 | 使叶子节点的接口变得复杂,增加了不必要的方法 |
安全组合模式 | 叶子节点接口简洁,不需要实现组合节点特有的方法 | 需要在客户端中区分叶子节点和组合节点,增加了代码复杂性 |
选择哪种实现方式应根据具体的需求和系统的复杂度来决定。如果系统中需要一致地处理叶子节点和组合节点,透明组合模式较为合适。如果希望叶子节点的接口简洁,可以选择安全组合模式。