一、组合模式概述
1.1 什么是组合模式
组合模式（Composite Pattern），也被称为部分-整体模式、合成模式或对象树，是一种结构型设计模式。这种模式将一组具有相似功能的对象视为一个单一的对象，使得客户可以以统一的方式处理单个对象和组合对象。
该模式依据树形结构来组合对象，用来表示部分以及整体层次。在特定的应用场景下，如需要表示的功能的结构可以被抽象成树状结构时，就非常适合使用组合模式。例如，在一个模拟的公司架构中，公司被视为一个整体，它下面可以设有行政部门和IT部门，而这些部门又可以有自己的下属部门。
总的来说，组合模式提供了一种方式来展示和操作层次性的结构化对象，增强了代码的灵活性和可维护性。
1.2 简单实现组合模式
实现组合模式的步骤如下：
- 1、定义一个抽象组件类，包含一个指向其子组件的引用。
- 2、创建具体组件类，这些类实现了抽象组件类中定义的方法。
- 3、创建一个组合组件类，该类也实现了抽象组件类中定义的方法。在组合组件类中，维护一个子组件列表，并实现添加、删除和遍历子组件的方法。
- 4、在客户端代码中，使用组合组件类来构建层次结构的对象，并通过调用抽象组件类中定义的方法来操作对象。
以下是一个简单的Java示例代码：
// 抽象组件类
abstract class Component {
protected String name;
public Component(String name) {
this.name = name;
}
public abstract void operation();
}
// 具体组件类A
class ConcreteComponentA extends Component {
public ConcreteComponentA(String name) {
super(name);
}
@Override
public void operation() {
System.out.println("ConcreteComponentA: " + name);
}
}
// 具体组件类B
class ConcreteComponentB extends Component {
public ConcreteComponentB(String name) {
super(name);
}
@Override
public void operation() {
System.out.println("ConcreteComponentB: " + name);
}
}
// 组合组件类
class CompositeComponent extends Component {
private List<Component> children = new ArrayList<>();
public CompositeComponent(String name) {
super(name);
}
public void add(Component component) {
children.add(component);
}
public void remove(Component component) {
children.remove(component);
}
@Override
public void operation() {
System.out.println("CompositeComponent: " + name);
for (Component child : children) {
child.operation();
}
}
}
// 客户端代码
public class Main {
public static void main(String[] args) {
CompositeComponent root = new CompositeComponent("Root");
CompositeComponent child1 = new CompositeComponent("Child1");
CompositeComponent child2 = new CompositeComponent("Child2");
root.add(child1);
root.add(child2);
ConcreteComponentA a1 = new ConcreteComponentA("A1");
ConcreteComponentB b1 = new ConcreteComponentB("B1");
ConcreteComponentA a2 = new ConcreteComponentA("A2");
ConcreteComponentB b2 = new ConcreteComponentB("B2");
child1.add(a1);
child1.add(b1);
child2.add(a2);
child2.add(b2);
root.operation();
}
}
在这个示例中，我们创建了一个组合组件CompositeComponent，它包含了两个子组件child1和child2。然后，我们在客户端代码中向这些子组件中添加了具体的组件ConcreteComponentA和ConcreteComponentB。最后，我们调用root.operation()方法，输出组合组件及其子组件的操作结果。
1.3 使用组合模式的注意事项
- 1、组合模式适用于具有层次结构的对象，如果对象之间没有明显的层次关系，则不适合使用组合模式。
- 2、抽象组件类应该定义一些通用的方法，如添加、删除和遍历子组件等方法，这些方法可以在具体组件类中进行重写。
- 3、组合组件类中的子组件列表可以使用数组或链表实现，但需要考虑性能问题。如果需要频繁地添加和删除子组件，建议使用链表；如果子组件数量较少且不需要频繁操作，可以使用数组。
- 4、在客户端代码中，可以通过组合组件类来构建复杂的对象结构，并通过调用抽象组件类中定义的方法来操作对象。
- 5、组合模式可以简化客户端代码的编写和维护，但如果滥用组合模式，可能会导致系统变得复杂和难以维护。因此，在使用组合模式时需要权衡利弊，避免过度设计。
二、组合模式的用途
- 1、定义层次结构：组合模式可以清晰地定义分层次的复杂对象，表示对象的全部或部分层次。
- 2、忽略层次差异：通过使用组合模式，客户端代码可以忽略层次之间的差异，从而方便对整个层次结构进行控制。
- 3、简化客户端代码：组合模式使得客户端代码可以一致地处理单个对象和组合对象，无需关心自己处理的是单个对象，还是组合对象，这大大简化了客户端代码。
- 4、符合开闭原则：组合模式允许在运行时添加新的元素，而无需更改源代码，这满足了“开闭原则”。
- 5、使设计变得更加抽象：通过使用组合模式，设计变得更加抽象，更具有一般性。
然而，值得注意的是，使用组合模式时也需要注意一些限制，例如当限制类型时，可能比较复杂；例如某个目录中只能包含文本文件，使用组合模式时，不能依赖类型系统施加约束，这些都必须来自于节点的抽象层，在这种情况下，必须通过在运行时进行类型检查，这样就会变得较为复杂。
三、组合模式实现方式
3.1 使用抽象组件类和具体组件类
// 抽象组件类
abstract class Component {
protected String name;
public Component(String name) {
this.name = name;
}
public abstract void operation();
}
// 具体组件类A
class ConcreteComponentA extends Component {
public ConcreteComponentA(String name) {
super(name);
}
@Override
public void operation() {
System.out.println("ConcreteComponentA: " + name);
}
}
// 具体组件类B
class ConcreteComponentB extends Component {
public ConcreteComponentB(String name) {
super(name);
}
@Override
public void operation() {
System.out.println("ConcreteComponentB: " + name);
}
}
// 组合组件类
class CompositeComponent extends Component {
private List<Component> components = new ArrayList<>();
public CompositeComponent(String name) {
super(name);
}
public void addComponent(Component component) {
components.add(component);
}
public void removeComponent(Component component) {
components.remove(component);
}
@Override
public void operation() {
System.out.println("CompositeComponent: " + name);
for (Component component : components) {
component.operation();
}
}
}
// 客户端代码
public class Main {
public static void main(String[] args) {
CompositeComponent composite = new CompositeComponent("Root");
Component componentA = new ConcreteComponentA("A");
Component componentB = new ConcreteComponentB("B");
composite.addComponent(componentA);
composite.addComponent(componentB);
composite.operation();
}
}
3.2 使用接口和实现类
// 组件接口
interface Component {
void operation();
}
// 具体组件类A
class ConcreteComponentA implements Component {
private String name;
public ConcreteComponentA(String name) {
this.name = name;
}
@Override
public void operation() {
System.out.println("ConcreteComponentA: " + name);
}
}
// 具体组件类B
class ConcreteComponentB implements Component {
private String name;
public ConcreteComponentB(String name) {
this.name = name;
}
@Override
public void operation() {
System.out.println("ConcreteComponentB: " + name);
}
}
// 组合组件类
class CompositeComponent implements Component {
private List<Component> components = new ArrayList<>();
public void addComponent(Component component) {
components.add(component);
}
public void removeComponent(Component component) {
components.remove(component);
}
@Override
public void operation() {
System.out.println("CompositeComponent");
for (Component component : components) {
component.operation();
}
}
}
// 客户端代码
public class Main {
public static void main(String[] args) {
CompositeComponent composite = new CompositeComponent();
Component componentA = new ConcreteComponentA("A");
Component componentB = new ConcreteComponentB("B");
composite.addComponent(componentA);
composite.addComponent(componentB);
composite.operation();
}
}