设计模式(13)——Composite 组合模式

一、组合模式定义

概述：将对象组合成树形结构以表示"部分-整体"的层次结构。"Composite"使得用户对单个对象和组合对象的使用具有一致性。

二、适用场合：

2.1当想表达对象的部分-整体的层次结构时（部门、菜单、树形结构）

2.2 希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象时。

三、模式解读

3.1类图

3.2组合模式中的角色

1. 组合部件（Component）：它是一个抽象角色，为要组合的对象提供统一的接口。
2. 叶子（Leaf）：在组合中表示子节点对象，叶子节点不能有子节点。
3. 合成部件（Composite）：定义有枝节点的行为，用来存储部件，实现在Component接口中的有关操作，如增加（Add）和删除（Remove）。

四、例子

部门人员的例子(经理有下属，编程人员没有下属)

组合部件--职员类

[java]  view plain copy print ?

1. import java.util.List;  
2.   
3. public abstract class Employer {  
4.   
5.     private String name;//职员姓名  
6.     private String positin;//职员职位  
7.     private int salary;//职员薪水  
8.   
9.     protected List<Employer> employers; //下属  
10.   
11.     public void setName(String name) {  
12.         this.name = name;  
13.     }  
14.   
15.     public String getName() {  
16.         return this.name;  
17.     }  
18.   
19.     public int getSalary() {  
20.         return salary;  
21.     }  
22.   
23.     public void setSalary(int salary) {  
24.         this.salary = salary;  
25.     }  
26.   
27.     public String getPositin() {  
28.         return positin;  
29.     }  
30.   
31.     public void setPositin(String positin) {  
32.         this.positin = positin;  
33.     }  
34.   
35.     public Employer(String name, String positin, int salary) {  
36.         this.name = name;  
37.         this.positin = positin;  
38.         this.salary = salary;  
39.     }  
40.   
41.     public abstract void add(Employer employer);//添加下属  
42.   
43.     public abstract void delete(Employer employer);//移除下属  
44.       
45.     //打印职工信息  
46.     public void printInfo() {  
47.         System.out.println(name + "\t" + positin + "    \t" + salary);  
48.     }  
49.   
50.     public List<Employer> getEmployers() {  
51.         return employers;  
52.     }  
53. }  

叶子类型----编程员 没有下属

[java]  view plain copy print ?

1. //程序员类 没有下属  
2. public class Programmer extends Employer {  
3.   
4.     public Programmer(String name, String positin, int salary) {  
5.         super(name, positin, salary);  
6.         employers = null;  
7.     }  
8.   
9.     // 程序员, 表示没有下属了  
10.     public void add(Employer employer) {  
11.   
12.     }  
13.   
14.     public void delete(Employer employer) {  
15.   
16.     }  
17. }  

树枝类型----项目经理 有下属

[html]  view plain copy print ?

1. //项目经理类 有下属  
2. import java.util.ArrayList;  
3.   
4. public class ProjectManager extends Employer {  
5.   
6.     public ProjectManager(String name, String positin, int salary) {  
7.         super(name, positin, salary);  
8.         employers = new ArrayList<Employer>();  
9.     }  
10.   
11.     public void add(Employer employer) {  
12.         employers.add(employer);  
13.     }  
14.   
15.     public void delete(Employer employer) {  
16.         if (employers.contains(employer)) {  
17.             employers.remove(employer);  
18.         }  
19.   
20.     }  
21.   
22. }  

Client

[html]  view plain copy print ?

1. import java.util.List;  
2.   
3. public class Client {  
4.   
5.     public static void main(String[] args) {  
6.         Employer pm = new ProjectManager("吴老板", "项目经理", 100000);  
7.   
8.         Employer pa = new ProjectManager("magang", "项目副经理", 3000);  
9.         Employer programmer1 = new Programmer("wsz", "程序员", 800);  
10.         Employer programmer2 = new Programmer("ss", "程序员", 800);  
11.         Employer programmer3 = new Programmer("xy", "程序员", 800);  
12.   
13.         pm.add(pa);// 为项目经理添加项目助理  
14.         pa.add(programmer1);// 项目经理加程序员  
15.         pa.add(programmer2);// 项目经理加程序员  
16.         pa.add(programmer3);// 项目经理加程序员  
17.   
18.         System.out.println("姓名\t" + "职位\t" + "         薪水\t");  
19.         printTreeInfo(pm);  
20.     }  
21.   
22.     public static void printTreeInfo(Employer root) {  
23.         root.printInfo();  
24.         if (root instanceof ProjectManager) {  
25.             List<Employer> list = root.getEmployers();  
26.             for (Employer employer : list)  
27.                 printTreeInfo(employer);  
28.   
29.         }  
30.   
31.     }  
32. }  

运行结果

 

姓名         职位          薪水  吴老板       项目经理      100000 magang       项目副经理    3000 wsz          程序员        800 ss           程序员        800 xy           程序员        800

 

五. 透明方式与安全方式

5.1透明方式：在Component中声明所有来管理子对象的方法，其中包括Add，Remove等。这样实现Component接口的所有子类都具备了Add和Remove方法。这样做的好处是叶节点和枝节点对于外界没有区别，它们具备完全一致的接口。

5.2安全方式：在Component中不去声明Add和Remove方法，那么子类的Leaf就不需要实现它，而是在Composit声明所有用来管理子类对象的方法。

5.3两种方式有缺点：对于透明方式，客户端对叶节点和枝节点是一致的，但叶节点并不具备Add和Remove的功能，因而对它们的实现是没有意义的；对于安全方式，叶节点无需在实现Add与Remove这样的方法，但是对于客户端来说，必须对叶节点和枝节点进行判定，为客户端的使用带来不便。

六. 模式总结

6.1 优点

6.1.1使客户端调用简单，它可以一致使用组合结构或是其中单个对象，简化了客户端代码。

6.1.2容易在组合体内增加对象部件。客户端不必因加入了新的部件而更改代码。有利于功能的扩展。

6.2 缺点

6.2.1需要抉择使用透明方式还是安全方式。

6.2.2透明方式违背了面向对象的单一职责原则；安全方式增加了客户需要端判定的负担。