组合模式（Composite）就是把部分和整体的关系用树形的结构来表示，从而使客户端能够把部分对象和组合起来的对象采用同样的方式来看待。
树图结构一般包含一个根节点，若干个树枝和叶子节点。如下图：
树结构的类图，其实就是组合模式的简略类图，最上面为抽象节点，左下方为叶子节点，右下方为树枝节点，它含有其他的节点。
1、抽象构建角色（component）：作为抽象角色，给组合对象的统一接口。
2、树叶构建角色（leaf）：代表组合对象中的树叶对象。
3、树枝构建角色（composite）：参加组合的所有子对象的对象，并给出树枝构构建对象的行为。
组合模式在现实中使用很常见，比如文件系统中目录和文件的组成，算式运算，android里面的view和viewgroup等控件，淘宝产品分类信息的展示等都是组合模式的例子。还有个故事：从前山里有座庙，庙里有个老和尚，老和尚对象小和尚讲故事说，从前山里有个庙......退出循环的条件是听厌烦了，或者讲的人讲累了。
这个模式的举例最多的是公司员工的例子。我们这里也以故事雇员为例子来描述：
1. package
2. /**
3. *
4. *作者：alaric
5. *时间：2013-7-20下午5:11:41
6. *描述：员工和领导的统一接口
7. */
8. public interface
9.
10. public void
11.
12. }
1. package
2. /**
3. *
4. *作者：alaric
5. *时间：2013-7-20下午5:59:11
6. *描述：普通员工类
7. */
8. public class Employe implements
9.
10. private
11.
12. public
13. super();
14. this.name = name;
15. }
16. @Override
17. public void
18. System.out.println(toString());
19. }
20.
21.
22. @Override
23. public
24. // TODO Auto-generated method stub
25. return "我叫"+getName()+",就一普通员工!";
26. }
27.
28. public
29. return
30. }
31.
32. public void
33. this.name = name;
34. }
35.
36. }
1. package
2.
3. import
4. import
5. import
6.
7. /**
8. *
9. *作者：alaric
10. *时间：2013-7-20下午5:14:50
11. *描述：领导类
12. */
13. public class Leader implements
14. private List<Worker> workers = new
15. private
16.
17. public
18. super();
19. this.name = name;
20. }
21. public void
22. workers.add(worker);
23. }
24.
25. public void
26. workers.remove(worker);
27. }
28.
29. public Worker getChild(int
30. return
31. }
32. @Override
33. public void
34. System.out.println(toString());
35. Iterator<Worker> it = workers.iterator();
36. while(it.hasNext()){
37. it.next().doSomething();
38. }
39.
40. }
41.
42.
43. @Override
44. public
45. // TODO Auto-generated method stub
46. return "我叫"+getName()+", 我是一个领导,有 "+workers.size()+"下属。";
47. }
48. public
49. return
50. }
51.
52. public void
53. this.name = name;
54. }
55.
56. }
1. package
2. /**
3. *
4. *作者：alaric
5. *时间：2013-7-20下午5:49:37
6. *描述：测试类
7. */
8. public class
9.
10. /**
11. *作者：alaric
12. *时间：2013-7-20下午5:49:32
13. *描述：
14. */
15. public static void
16. // TODO Auto-generated method stub
17. new Leader("张三");
18. new Leader("李四");
19. new Employe("王五");
20. new Employe("赵六");
21. new Employe("陈七");
22. new Employe("徐八");
23. leader1.add(leader2);
24. leader1.add(employe1);
25. leader1.add(employe2);
26. leader2.add(employe3);
27. leader2.add(employe4);
28. leader1.doSomething();
29.
30. }
运行结果如下：
我叫张三, 我是一个领导,有 3个直接下属。
我叫李四, 我是一个领导,有 2个直接下属。
我叫陈七,就一普通员工!
我叫徐八,就一普通员工!
我叫王五,就一普通员工!
我叫赵六,就一普通员工!
上面员工关系的的树形结构如下：
上面例子给出的组合模式抽象角色里，并没有管理子节点的方法，而是在树枝构建角色，这种模式使得叶子构建角色和树枝构建角色有区分，客户端要分别对待树叶构建角色和树枝构建角色，好处是客户端对叶子节点不会调用管理的方法，当调用时，在编译时就会报错，所以也称安全模式。相对安全模式，还有一种透明模式，就是在抽象角色里面添加管理方法，如下图：
这种做法是对客户端来说叶子和树枝都是一致的接口，相对透明，但是叶子节点在调用管理方法是编译时不会报错，运行时才报错，所以不够安全。两种做法均有利弊，使用时要根据具体情况而权衡。
- composite.rar (1.8 KB)
- 下载次数: 13
