alexpdh's blog

Java设计模式(十六):组合模式

组合模式(composite pattern)

组合模式(composite pattern):属于对象的结构型模式。将对象组合成树形结构以表示‘部分-整体’的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。


组合模式UML图

composite-pattern


组合模式涉及的角色

抽象构件(Component)角色:组合中的对象声明接口,在适当情况下,实现所有类共有接口的默认行为。声明一个接口用于访问和管理 Component 的子不部件
树叶构件(Leaf)角色:在组合中表示叶节点对象,叶节点没有子节点
树枝构件(Composite)角色:定义有枝节点行为,用来存储子部件,在 Component 接口中实现与子部件有关的操作,比如 增加 add 和删除 remove


组合模式的实现方式

  • 透明方式

要求在 Component 中申明所有的管理方法,如: add 和 remove 方法,所有实现 Component 类的子类都实现了这些管理方法。这样做的好处是无论是树叶节点还是树枝节点对于外界是没有区别的,它们具备完全一致的行为接口。但问题也很明显,因为 树叶节点(Leaf)本身并不具备管理方法的功能,所以实现它是没有意义的。

  • 安全方式

也就是在 Component 类中不去声明 add 和 remove 方法,那么子类的 Leaf 也就不需要去是实现它,而是在 Composite 类声明所有用来管理子类的对象的方法,这样做就不会出现透明方式的问题,不过由于不透明,所以树叶和树枝类将不具有相同的接口,客户端调用需要作出相应的判断,带来了不变。

在组成模式中,建议多采用透明方式


示例代码

抽象构建类 Component

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
package com.example.compositePattern;
/**
* 组合模式:抽象构建类
*
* @author pengdh
* @date: 2017-07-23 18:52
*/
public abstract class Component {
protected String name;
public Component(String name) {
this.name = name;
}
/**
* 添加一个子部件对象
* @param c
*/
public abstract void add(Component c);
/**
* 删除一个子部件对象
* @param c
*/
public abstract void remove(Component c);
/**
* 显示目录树
* @param depth
*/
public abstract void display(String depth);
}

树叶构件类 Leaf

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
package com.example.compositePattern;
/**
* 组合模式:树叶构件类
*
* @author pengdh
* @date: 2017-07-23 18:59
*/
public class Leaf extends Component {
public Leaf(String name) {
super(name);
}
@Override
public void add(Component c) {
return;
}
@Override
public void remove(Component c) {
return;
}
@Override
public void display(String depth) {
System.out.println(depth + " " + name);
}
}

树枝构件类 Composite

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
package com.example.compositePattern;
import java.util.ArrayList;
import java.util.List;
/**
* 组合模式:树枝构件类
*
* @author pengdh
* @date: 2017-07-23 19:10
*/
public class Composite extends Component {
private List<Component> childrenComopnents = new ArrayList<Component>();
public Composite(String name) {
super(name);
}
@Override
public void add(Component c) {
childrenComopnents.add(c);
}
@Override
public void remove(Component c) {
childrenComopnents.remove(c);
}
@Override
public void display(String depth) {
System.out.println(depth + " " + name);
depth += "+";
for (Component component : childrenComopnents) {
component.display(depth);
}
}
}

客户端测试类 TestCompositePattern

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
package com.example.compositePattern;
/**
* 组合模式:客户端测试类
*
* @author pengdh
* @date: 2017-07-23 19:16
*/
public class TestCompositePattern {
public static void main(String[] args) {
// 添加根节点
Composite root = new Composite("root");
// 根节点上添加叶子节点
root.add(new Leaf("Leaf A"));
root.add(new Leaf("Leaf B"));
// 添加树枝节点
Composite comp = new Composite("Composite X");
// 树枝节点上添加叶子节点
comp.add(new Leaf("Leaf XA"));
comp.add(new Leaf("Leaf XB"));
// 将树枝节点添加到根节点
root.add(comp);
Composite comp2 = new Composite("Composite XY");
comp2.add(new Leaf("Leaf XYA"));
comp2.add(new Leaf("Leaf XYB"));
root.add(comp2);
root.add(new Leaf("Leaf C"));
Leaf leaf = new Leaf("D");
root.add(leaf);
root.remove(leaf);
root.display("+");
}
}

参考文献

alexpdh wechat
欢迎扫一扫关注 程序猿pdh 公众号!