本文最后更新于 2025年7月25日 晚上
组合模式组合多个对象形成树形结构，以表示“整体-部分”的结构层次
角色
- 组合中的对象声明接口 ： 在适当的情况下，实现所有类共有接口的默认行为，声明一个接口用于访问和管理子部件
- 叶子对象 ：叶子节点没有子节点
- 容器对象 ：定义有枝节点行为，用来存储子部件
实现组合模式
以公司架构模式实现组合模式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
| public abstract class Company{
protected String name ;
public Company(String name){
this.name = name ;
}
public abstract void add(Company company);
public abstract void remove(Company company);
public abstract void display(int depth);
public abstract void duty();
}
public class ConcreteCompany extends Company{
private List<Company> companyList = new ArrayList<>();
public ConcreteCompany(String name){
super(name);
}
@Override
public void add(Company company){
companyList.add(company);
}
@Override
public void remove(Company company){
companyList.remove(company);
}
@Override
public void display(int depth){
for(int i = 0 ; i < depth ; i++){
System.out.println("-");
}
System.out.println(name);
for(Company company:companyList){
company.display(depth+1);
}
}
@Override
public void duty(){
for(Company company:companyList){
company.duty();
}
}
}
public class HRDepartment extends Company{
public HRDepartment (String name){
super(name);
}
@Override
public void add(Company company){
}
@Override
public void remove(Company company){
}
@Override
public void display(int depth){
for(int i = 0 ; i < depth ; i++){
System.out.print('-');
}
System.out.println(name);
}
@Override
public void duty() {
System.out.println(name + "人员管理");
}
}
public class FinanceDepartment extends Company{
public FinanceDepartment(String name){
super(name);
}
@Override
public void add(Company company){
}
@Override
public void remove(Company company){
}
@Override
public void display(int depth){
for(int i = 0 ; i < depth ; i++ ){
System.out.print('-');
}
System.out.println(name);
}
@Override
public void duty(){
System.out.println(name + "财务管理");
}
}
public class Client{
public static void main(String[] args){
Company headCompany = new ConcreteCompany("总公司");
Company branchCompany = new ConcreteCompany("分公司");
branchCompany.add(new HRDepartment("分公司人力资源部"));
branchCompany.add(new FinanceDepartment("分公司财务部"));
headCompany.add(branchCompany);
}
}
|
可以看出 组合模式的逻辑是 在一个抽象类定义下，
定义两套不同的功能 ：
- 作为容器部分的对于叶子节点的管理。
- 作为叶子节点所具备的自身功能。
通过分别实现不同的方法，完成功能调用和管理两种能力。
将两种能力“组合” 到同一个类定义中，对外界来说提供一致的调用方法。
透明模式与安全模式
根据一致性需要的不同，可以对组合模式进行两种不同的实现
透明模式 ： 在基类中定义所有的方法 ，优点是调用程序可以进行一致性调用，但叶子节点实现的对象管理方法是不存在的。
安全模式 ： 在基类中只定义容器和叶子都需要的方法，在容器接口中定义对象管理方法。优点是叶子对象不必再重写不必要的方法，缺点是访问的一致性被破坏。需要调用程序判断对象是否可以进行对应方法的调用。
1
2
3
4
5
6
7
8
9
10
11
|
interface Company {
void display(int depth);
void duty();
}
interface CompanyComposite extends Company {
void add(Company company);
void remove(Company company);
}
|
总结
组合模式（Composite Pattern）是一种结构型设计模式，旨在通过将对象组织成树形结构，实现“整体-部分”的统一管理。它使客户端能够以一致的方式对待单个对象与组合对象，极大地提升了系统的扩展性与可维护性。