24种设计模式--组合模式【Composite Pattern】
大家在上学的时候应该都学过“数据结构”这门课程吧，还记得其中有一节叫“二叉树”吧，我们上学那会儿这一章节是必考内容，左子树，右子树，什么先序遍历后序遍历什么，重点就是二叉树的的遍历，我还记得当时老师就说，考试的时候一定有二叉树的构建和遍历，现在想起来还是觉的老师是正确的，树状结果在实际项目应用的非常广泛。
咱就先说个最常见的例子，公司的人事管理就是一个典型的树状结构，你想想你公司的结构是不是这样:
从最高的老大，往下一层一层的管理，最后到我们这层小兵，很典型的树状结构（说明一下，这不是二叉树，有关二叉树的定义可以翻翻以前的教科书），我们今天的任务就是要把这个树状结构实现出来，并且还要把它遍历一遍，你要确认你建立的树是否有问题呀。
从这个树状结构上分析，有两种节点：有分支的节点（如研发部经理）和无分支的节点（如员工 A、员工 D 等），我们增加一点学术术语上去，总经理叫做根节点(是不是想到 XML 的那个根节点 root，那就对了)，类似研发部经理有分支的节点叫做树枝节点，类似员工 A 的无分支的节点叫做树叶节点，都很形象，三个类型的的节点，那是不是定义三个类就可以？好，我们按照这个思路走下去，先看我们自己设计的类图：
这个类图是初学者最容易想到的类图（如果你已经看明白这个类图的缺陷了，就可以不看下边的实现了，我是循序渐进的讲课，呵呵），那我们来看这个实现：
先看最高级别的根节点的实现：
1 package com.pattern.composite;
2
3 import java.util.ArrayList;
4
5 /**
6 * 定义一个根节点，就为总经理服务
7 * @author http://www.cnblogs.com/initial-road/
8 *
9 */
10 public interface IRoot {
11
12 // 得到总经理的信息
13 public String getInfo();
14
15 // 总经理下边要有小兵，那要能增加小兵，比如研发总经理，这是个树枝节点
16 public void add(IBranch branch);
17
18 // 那要能增加树叶节点
19 public void add(ILeaf leaf);
20
21 // 既然能增加，那要还要能够便遍历，不肯能总经理不知道他手下有哪些人
22 public ArrayList getSubordinateInfo();
23
24 }
25
26 // 这个根节点就是我们的总经理 CEO，然后看实现类：
27
28 package com.pattern.composite;
29
30 import java.util.ArrayList;
31
32 /**
33 * 根节点的实现类
34 * @author http://www.cnblogs.com/initial-road/
35 *
36 */
37 @SuppressWarnings("unchecked")
38 public class Root implements IRoot {
39 // 保存根节点下的树枝节点和树叶节点，Subrdinate的意思是下级
40 private ArrayList subordinateList = new ArrayList();
41
42 // 根节点的名称
43 private String name = "";
44
45 // 根节点的职位
46 private String position = "";
47
48 // 根节点的薪水
49 private int salary = 0;
50
51 // 通过构造函数传递进来总经理的信息
52 public Root(String name, String position, int salary){
53 this.name = name;
54 this.position = position;
55 this.salary = salary;
56 }
57
58 // 增加树枝节点
59 public void add(IBranch branch) {
60 this.subordinateList.add(branch);
61 }
62
63 // 增加叶子节点，比如秘书，直接属于总经理
64 public void add(ILeaf leaf) {
65 this.subordinateList.add(leaf);
66 }
67
68 // 得知自己的信息
69 public String getInfo() {
70 String info = "";
71 info = "名称：" + this.name;
72 info = info + "\t职位：" + this.position;
73 info = info + "\t薪水：" + this.salary;
74 return info;
75 }
76
77 // 得到下级的信息
78 public ArrayList getSubordinateInfo() {
79 return this.subordinateList;
80 }
81
82 }
很简单，通过构造函数传入参数，然后获得信息，还可以增加子树枝节点（部门经理）和叶子节点（秘书）。我们再来看 IBranch.java:
1 package com.pattern.composite;
2
3 import java.util.ArrayList;
4
5 /**
6 * 树枝节点，也就是各个部门经理和组长的角色
7 * @author http://www.cnblogs.com/initial-road/
8 *
9 */
10 @SuppressWarnings("unchecked")
11 public interface IBranch {
12
13 // 获得信息
14 public String getInfo();
15
16 // 增加数据节点，例如研发部下的研发一组
17 public void add(IBranch branch);
18
19 // 增加叶子节点
20 public void add(ILeaf leaf);
21
22 // 获得下级信息
23 public ArrayList getSubordinateInfo();
24
25 }
26
27 // 下面是树枝节点的实现类：
28 package com.pattern.composite;
29
30 import java.util.ArrayList;
31
32 /**
33 * 所有的树枝节点
34 * @author http://www.cnblogs.com/initial-road/
35 *
36 */
37 @SuppressWarnings("unchecked")
38 public class Branch implements IBranch {
39 // 存储子节点信息
40 private ArrayList subordinateList = new ArrayList();
41
42 // 树枝节点的名称
43 private String name = "";
44
45 // 树枝节点的职位
46 private String position = "";
47
48 // 树枝节点的薪水
49 private int salary = 0;
50
51 // 通过构造函数传递树枝节点的参数
52 public Branch(String name, String position, int salary){
53 this.name = name;
54 this.position = position;
55 this.salary = salary;
56 }
57
58 // 增加一个子树枝节点
59 public void add(IBranch branch) {
60 this.subordinateList.add(branch);
61 }
62
63 // 增加一个叶子节点
64 public void add(ILeaf leaf) {
65 this.subordinateList.add(leaf);
66 }
67
68 // 获得自己树枝节点的信息
69 public String getInfo() {
70 String info = "";
71 info = "名称：" + this.name;
72 info = info + "\t职位：" + this.position;
73 info = info + "\t薪水：" + this.salary;
74 return info;
75 }
76
77 // 获得下级的信息
78 public ArrayList getSubordinateInfo() {
79 return this.subordinateList;
80 }
81
82 }
83
84 // 最后看叶子节点，也就是员工的接口：
85
86 package com.pattern.composite;
87
88 /**
89 * 叶子节点，也就是最小的小兵了，只能自己干活，不能指派别人了
90 * @author http://www.cnblogs.com/initial-road/
91 *
92 */
93 public interface ILeaf {
94
95 // 获得自己的信息呀
96 public String getInfo();
97
98 }
99
100 // 下面是叶子节点的实现类：
101
102 package com.pattern.composite;
103
104 /**
105 * 最小的叶子节点
106 * @author http://www.cnblogs.com/initial-road/
107 *
108 */
109 public class Leaf implements ILeaf {
110 // 叶子叫什么名字
111 private String name = "";
112
113 // 叶子的职位
114 private String position = "";
115
116 // 叶子的薪水
117 private int salary = 0;
118
119 // 通过构造函数传递信息
120 public Leaf(String name, String position, int salary){
121 this.name = name;
122 this.position = position;
123 this.salary = salary;
124 }
125
126 // 最小的小兵只能获得自己的信息了
127 public String getInfo() {
128 String info = "";
129 info = "名称：" + this.name;
130 info = info + "\t职位：" + this.position;
131 info = info + "\t薪水：" + this.salary;
132 return info;
133 }
134
135 }
好了，所有的根节点，树枝节点和叶子节点都已经实现了，从总经理、部门经理到最终的员工都已经实现了，然后的工作就是组装成一个树状结构和遍历这个树状结构，看 Client.java 程序：
1 package com.pattern.composite;
2
3 import java.util.ArrayList;
4
5 /**
6 * Client的作用是组装这棵树，并遍历一遍
7 * @author http://www.cnblogs.com/initial-road/
8 *
9 */
10 @SuppressWarnings("unchecked")
11 public class Client {
12
13 public static void main(String[] args) {
14
15 // 首先产生了一个根节点
16 IRoot ceo = new Root("张三", "总经理", 100000);
17
18 // 差生三个部门经理，也就是树枝节点
19 IBranch developDep = new Branch("李四", "研发部门经理", 10000);
20 IBranch salesDep = new Branch("王五", "销售部门经理", 20000);
21 IBranch financeDep = new Branch("赵六", "财务部门经理", 30000);
22
23 // 再把三个小组长产生出来
24 IBranch firstDevGroup = new Branch("杨三", "开发一组组长", 5000);
25 IBranch secondDevGroup = new Branch("吴大", "开发二组组长", 6000);
26
27 // 剩下的就是我们这些小兵了，就是路人甲，路人乙
28 ILeaf a = new Leaf("a", "开发人员", 2000);
29 ILeaf b = new Leaf("b", "开发人员", 2000);
30 ILeaf c = new Leaf("c", "开发人员", 2000);
31 ILeaf d = new Leaf("d", "开发人员", 2000);
32 ILeaf e = new Leaf("e", "开发人员", 2000);
33 ILeaf f = new Leaf("f", "开发人员", 2000);
34 ILeaf g = new Leaf("g", "开发人员", 2000);
35 ILeaf h = new Leaf("h", "开发人员", 5000);
36 ILeaf i = new Leaf("i", "开发人员", 4000);
37 ILeaf j = new Leaf("j", "开发人员", 5000);
38 ILeaf k = new Leaf("k", "开发人员", 8000);
39 ILeaf zhengLaoLiu = new Leaf("郑老六", "研发部副总", 20000);
40
41 // 该产生的人都产生出来了，然后我们怎么组装这棵树
42 // 首先是定义总经理下有三个部门经理
43 ceo.add(developDep);
44 ceo.add(salesDep);
45 ceo.add(financeDep);
46 //总经理下还有一个秘书
47 ceo.add(k);
48
49 // 定义研发部门下的结构
50 developDep.add(firstDevGroup);
51 developDep.add(secondDevGroup);
52
53 // 研发部经理下还有一个副总
54 developDep.add(zhengLaoLiu);
55
56 // 看看开发两个小组下有什么
57 firstDevGroup.add(a);
58 firstDevGroup.add(b);
59 firstDevGroup.add(c);
60
61 secondDevGroup.add(d);
62 secondDevGroup.add(e);
63 secondDevGroup.add(f);
64 secondDevGroup.add(g);
65
66 // 再看销售部下的人员情况
67 salesDep.add(h);
68 salesDep.add(i);
69
70 // 最后一个财务
71 financeDep.add(j);
72
73 // 树状结构写完毕，然后我们打印出来
74 System.out.println(ceo.getInfo());
75
76 // 打印出来整个树形
77 getAllSubordinateInfo(ceo.getSubordinateInfo());
78 }
79
80 private static void getAllSubordinateInfo(ArrayList subordinateList){
81 int length = subordinateList.size();
82 for(int m=0;m<length;m++){
83 Object s = subordinateList.get(m);
84 if(s instanceof Leaf){
85 // 是个叶子节点，也就是员工
86 ILeaf employee = (ILeaf) s;
87 System.out.println(employee.getInfo());
88 }else{
89 IBranch branch = (IBranch) s;
90 System.out.println(branch.getInfo());
91 // 在递归调用
92 getAllSubordinateInfo(branch.getSubordinateInfo());
93 }
94 }
95 }
96 }
这个程序比较长，如果是在我们的项目中有这样的程序，肯定是被拉出来做典型的，你写一大坨的程序给谁呀，以后还要维护的，程序是要短小精悍！幸运的是，我们是这为案例来讲解，而且就是指出这样组装这棵树是有问题，等会我们深入讲解。
和我们期望要的结果一样，一棵完整的树就生成了，而且我们还能够遍历。看类图或程序的时候，你有没有发觉有问题？getInfo 每个接口都有为什么不能抽象出来？Root 类和Branch 类有什么差别？为什么要定义成两个接口两个类?如果我要加一个任职期限，你是不是每个类都需要修改？如果我要后序遍历（从员工找到他的上级领导）能做吗？——彻底晕菜了！
问题很多，我们一个一个解决，先说抽象的问题，确实可以吧 IBranch 和 IRoot 合并成一个接口，这个我们先肯定下来，这是个比较大的改动，我们先画个类图：
这个类图还是有点问题的，接口的作用是什么？定义共性，那 ILeaf 和 IBranch 是不是也有共性呢？有 getInfo（），我们是不是要把这个共性也已经封装起来呢？好，我们再修改一下类图：
类图上有两个接口，ICorp 是公司所有人员的信息的接口类，不管你是经理还是员工，你都有名字，职位，薪水，这个定义成一个接口没有错，IBranch 有没有必要呢？我们先实现出来然后再说。
先看 ICorp.java 源代码：
1 package com.pattern.composite.advance;
2
3 /**
4 * 公司类，定义每个员工都有信息
5 * @author http://www.cnblogs.com/initial-road/
6 *
7 */
8 public interface ICorp {
9
10 // 每个员工都有信息，你想隐藏，门儿都没有！
11 public String getInfo();
12
13 }
14
15 // 接口很简单，只有一个方法，就是获得员工的信息，我们再来看实现类：
16
17 package com.pattern.composite.advance;
18
19 /**
20 * Leaf是树枝节点，在这里就是我们这些小兵
21 * @author http://www.cnblogs.com/initial-road/
22 *
23 */
24 public class Leaf implements ICorp {
25
26 // 小兵也有名称
27 private String name = "";
28
29 // 小兵也有职位
30 private String position = "";
31
32 // 小兵也有薪水，否则谁给你干
33 private int salary = 0;
34
35 // 通过一个构造函数传递小兵的信息
36 public Leaf(String name, String position, int salary) {
37 this.name = name;
38 this.position = position;
39 this.salary = salary;
40 }
41
42 // 获得小兵的信息
43 public String getInfo() {
44 String info = "";
45 info = "姓名：" + this.name;
46 info = info + "\t职位：" + this.position;
47 info = info + "\t薪水：" + this.salary;
48 return info;
49 }
50
51 }
小兵就只有这些信息了，我们是具体干活的，我们是管理不了其他同事的，我们来看看那些经理和小组长是怎么实现的，先看接口：
1 package com.pattern.composite.advance;
2
3 import java.util.ArrayList;
4
5 /**
6 * 这些下边有小兵或者是经理等风云人物
7 * @author http://www.cnblogs.com/initial-road/
8 *
9 */
10 public interface IBranch {
11
12 // 能够增加小兵（树叶节点）或者是经过（树枝节点）
13 public void addSubordinate(ICorp corp);
14
15 // 还要能够获得下属的信息
16 public ArrayList<ICorp> getSubordinate();
17
18 /**
19 * 本来还应该又一个方法 delSubordinate(ICorp corp),删除下属
20 * 这个方法我们没有用到就不写进来了
21 */
22 }
23
24 // 接口也是很简单的，下面是实现类：
25
26 package com.pattern.composite.advance;
27
28 import java.util.ArrayList;
29
30 /**
31 * 这些树枝节点也就是这些领导们既要自己的信息，还要知道自己的下属情况
32 * @author http://www.cnblogs.com/initial-road/
33 *
34 */
35 public class Branch implements IBranch, ICorp{
36 // 领导也是人，也有名字
37 private String name = "";
38
39 // 领导和领导不同，也是职位区别
40 private String position = "";
41
42 // 领导也是拿薪水的
43 private int salary = 0;
44
45 // 领导下边有那些下级领导和小兵
46 ArrayList<ICorp> subordinateList = new ArrayList<ICorp>();
47
48 // 通过构造函数传递领导的信息
49 public Branch(String name, String position, int salary) {
50 this.name = name;
51 this.position = position;
52 this.salary = salary;
53 }
54
55 // 增加一个下属，可能是小头目，也可能是个小兵
56 public void addSubordinate(ICorp corp) {
57 this.subordinateList.add(corp);
58 }
59
60 // 我有哪些下属
61 public ArrayList<ICorp> getSubordinate() {
62 return this.subordinateList;
63 }
64
65 // 领导也是人，他也有信息
66 public String getInfo() {
67 String info = "";
68 info = "姓名：" + this.name;
69 info = info + "\t职位：" + this.position;
70 info = info + "\t薪水：" + this.salary;
71 return info;
72 }
73 }
74
75 // 实现类也很简单，不多说，程序写的好不好，就看别人怎么调用了，我们看Client.java 程序：
76
77 package com.pattern.composite.advance;
78
79 import java.util.ArrayList;
80
81 /**
82 * 组装这个树形结构，并展示出来
83 * @author http://www.cnblogs.com/initial-road/
84 *
85 */
86 @SuppressWarnings("all")
87 public class Client {
88
89 public static void main(String[] args) {
90
91 // 首先是组装一个组织结构出来
92 Branch ceo = compositeCorpTree();
93
94 // 首先把CEO的信息打印出来
95 System.out.println(ceo.getInfo());
96
97 // 然后是所有员工信息
98 System.out.println(getTreeInfo(ceo));
99 }
100
101 // 把整个树组装出来
102 public static Branch compositeCorpTree(){
103 // 首先产生总经理CEO
104 Branch root = new Branch("张三", "总经理", 10000);
105
106 // 把三个部门经理产生出来
107 Branch developDep = new Branch("李四", "研发部门经理", 10000);
108 Branch salesDep = new Branch("王五", "销售部门经理", 20000);
109 Branch financeDep = new Branch("赵六", "财务部经理", 30000);
110
111 // 再把三个小组长产生出来
112 Branch firstDevGroup = new Branch("周七", "开发一组组长", 5000);
113 Branch secondDevGroup = new Branch("杨三", "开发二组组长", 6000);
114
115 // 把所有的小兵都产生出来
116 Leaf a = new Leaf("a", "开发人员", 2000);
117 Leaf b = new Leaf("b", "开发人员", 2000);
118 Leaf c = new Leaf("c", "开发人员", 2000);
119 Leaf d = new Leaf("d", "开发人员", 2000);
120 Leaf e = new Leaf("e", "开发人员", 2000);
121 Leaf f = new Leaf("f", "开发人员", 2000);
122 Leaf g = new Leaf("g", "开发人员", 2000);
123 Leaf h = new Leaf("h", "销售人员", 5000);
124 Leaf i = new Leaf("i", "销售人员", 4000);
125 Leaf j = new Leaf("j", "财务人员", 5000);
126 Leaf k = new Leaf("k", "CEO秘书", 8000);
127 Leaf zhengLaoLiu = new Leaf("郑老六", "研发部副经理", 20000);
128
129 // 开始组装
130 // CEO下有三个部门经理和一个秘书
131 root.addSubordinate(k);
132 root.addSubordinate(developDep);
133 root.addSubordinate(salesDep);
134 root.addSubordinate(financeDep);
135
136 // 研发部经理
137 developDep.addSubordinate(zhengLaoLiu);
138 developDep.addSubordinate(firstDevGroup);
139 developDep.addSubordinate(secondDevGroup);
140
141 // 看看开发两个小组下有什么
142 firstDevGroup.addSubordinate(a);
143 firstDevGroup.addSubordinate(b);
144 firstDevGroup.addSubordinate(c);
145 secondDevGroup.addSubordinate(d);
146 secondDevGroup.addSubordinate(e);
147 secondDevGroup.addSubordinate(f);
148
149 // 再看销售部下的人员情况
150 salesDep.addSubordinate(h);
151 salesDep.addSubordinate(i);
152
153 // 最后一个财务
154 financeDep.addSubordinate(j);
155
156 return root;
157 }
158
159 // 遍历整棵树，只要给我根节点，我就能遍历出所有的节点
160 public static String getTreeInfo(Branch root){
161 ArrayList<ICorp> subordinate = root.getSubordinate();
162 String info = "";
163 for(ICorp s : subordinate){
164 // 是员工就直接获得信息
165 if(s instanceof Leaf){
166 info = info + s.getInfo() + "\n";
167 }else{
168 // 是个小头目
169 info = info + s.getInfo() + "\n" + getTreeInfo((Branch) s);
170 }
171 }
172 return info;
173 }
174
175 }
一个非常清晰的树状人员资源管理图出现了，那我们的程序是否还可以优化？可以！ 你看 Leaf 和 Branch中都有 getInfo 信息，是否可以抽象，好，我们抽象一下：
你一看这个图，乐了，能不乐嘛，减少很多工作量了，接口没有了，改成抽象类了，IBranch 接口也没有了，直接把方法放到了实现类中了，那我们先来看抽象类：
1 package com.pattern.composite.perfect;
2
3 /**
4 * 定义一个公司的人员的抽象类
5 * @author http://www.cnblogs.com/initial-road/
6 *
7 */
8 public abstract class Corp {
9
10 // 公司每个人都有名称
11 private String name = "";
12
13 // 公司每个人都有职位
14 private String position = "";
15
16 // 公司每个人都有薪水
17 private int salary = 0;
18
19 /**
20 * 通过接口的方式传递，我们改变一下习惯，传递进来的变量名以下划线开始
21 * 这个在一些开源项目中非常常见，一般构造函数都是这么定义的
22 */
23 public Corp(String _name, String _position, int _salary){
24 this.name = _name;
25 this.position = _position;
26 this.salary = _salary;
27 }
28
29 // 获得员工信息
30 public String getInfo(){
31 String info = "";
32 info = "姓名：" + this.name;
33 info = info + "\t职位：" + this.position;
34 info = info + "\t薪水：" + this.salary;
35 return info;
36 }
37
38 }
39
40 // 抽象类嘛，就应该抽象出一些共性的东西出来，然后看两个具体的实现类：
41
42 package com.pattern.composite.perfect;
43
44 /**
45 * 普通员工很简单，就写一个函数就可以了
46 * @author http://www.cnblogs.com/initial-road/
47 *
48 */
49 public class Leaf extends Corp {
50
51 // 就写一个构造函数，这个是必须的
52 public Leaf(String name, String position, int salary) {
53 super(name, position, salary);
54 }
55
56 }
57
58 // 这个改动比较多，就几行代码就完成了，确实就应该这样，下面是小头目的实现类：
59
60 package com.pattern.composite.perfect;
61
62 import java.util.ArrayList;
63
64 /**
65 * 节点类，也简单了很多
66 * @author http://www.cnblogs.com/initial-road/
67 *
68 */
69 public class Branch extends Corp {
70
71 // 领导下边有那些下级领导和小兵
72 ArrayList<Corp> subordinateList = new ArrayList<Corp>();
73
74 // 构造函数是必须的了
75 public Branch(String _name, String _position, int _salary) {
76 super(_name, _position, _salary);
77 }
78
79 // 增加一个下属，可能是小头目，也可能是个小兵
80 public void addSubordinate(Corp corp){
81 this.subordinateList.add(corp);
82 }
83
84 // 我有哪些下属
85 public ArrayList<Corp> getSubordinate(){
86 return this.subordinateList;
87 }
88
89 }
90
91 // 也缩减了很多，再看 Client.java 程序，这个就没有多大变化了：
92
93 package com.pattern.composite.perfect;
94
95 import java.util.ArrayList;
96
97 /**
98 * 组装这个树形结构，并展示出来
99 * @author http://www.cnblogs.com/initial-road/
100 *
101 */
102 public class Client {
103
104 public static void main(String[] args) {
105
106 // 首先是组装一个组织结构出来
107 Branch ceo = compositeCorpTree();
108
109 // 首先把CEO的信息打印出来
110 System.out.println(ceo.getInfo());
111
112 // 然后是所有员工信息
113 System.out.println(getTreeInfo(ceo));
114 }
115
116 // 把整个树组装出来
117 public static Branch compositeCorpTree(){
118 // 首先产生总经理CEO
119 Branch root = new Branch("张三", "总经理", 10000);
120
121 // 把三个部门经理产生出来
122 Branch developDep = new Branch("李四", "研发部门经理", 10000);
123 Branch salesDep = new Branch("王五", "销售部门经理", 20000);
124 Branch financeDep = new Branch("赵六", "财务部经理", 30000);
125
126 // 再把三个小组产生出来
127 Branch firstDevGroup = new Branch("杨三", "开发一组组长", 5000);
128 Branch secondDevGroup = new Branch("吴大", "开发二组组长", 6000);
129
130 // 把所有的小兵都产生出来
131 Leaf a = new Leaf("a", "开发人员", 2000);
132 Leaf b = new Leaf("b", "开发人员", 2000);
133 Leaf c = new Leaf("c", "开发人员", 2000);
134 Leaf d = new Leaf("d", "开发人员", 2000);
135 Leaf e = new Leaf("e", "开发人员", 2000);
136 Leaf f = new Leaf("f", "开发人员", 2000);
137 Leaf g = new Leaf("g", "开发人员", 2000);
138 Leaf h = new Leaf("h", "销售人员", 5000);
139 Leaf i = new Leaf("i", "销售人员", 4000);
140 Leaf j = new Leaf("j", "财务人员", 5000);
141 Leaf k = new Leaf("k", "CEO秘书", 8000);
142 Leaf zhengLaoLiu = new Leaf("郑老六", "研发部副总理", 20000);
143
144 // 开始组装
145 // CEO下有三个部门经理和一个秘书
146 root.addSubordinate(k);
147 root.addSubordinate(developDep);
148 root.addSubordinate(salesDep);
149 root.addSubordinate(financeDep);
150
151 // 研发部门经理
152 developDep.addSubordinate(zhengLaoLiu);
153 developDep.addSubordinate(firstDevGroup);
154 developDep.addSubordinate(secondDevGroup);
155
156 // 看看两个开发小组下有什么
157 firstDevGroup.addSubordinate(a);
158 firstDevGroup.addSubordinate(b);
159 firstDevGroup.addSubordinate(c);
160 secondDevGroup.addSubordinate(d);
161 secondDevGroup.addSubordinate(e);
162 secondDevGroup.addSubordinate(f);
163 secondDevGroup.addSubordinate(g);
164
165 // 再看销售部下的人员情况
166 salesDep.addSubordinate(h);
167 salesDep.addSubordinate(i);
168
169 // 最后一个财务
170 financeDep.addSubordinate(j);
171 return root;
172 }
173
174 // 遍历整棵树，只要给我根节点，我就能遍历出所有的节点
175 public static String getTreeInfo(Branch branch){
176 ArrayList<Corp> subordinateList = branch.getSubordinate();
177 String info = "";
178 for(Corp s : subordinateList){
179 if(s instanceof Leaf){
180 // 是员工就直接获得信息
181 info = info + s.getInfo() + "\n";
182 }else{
183 info = info + s.getInfo() + "\n" + getTreeInfo((Branch) s);
184 }
185 }
186 return info;
187 }
188 }
就是把用到 ICorp 接口的地方修改为 Corp 抽象类就成了，就上面黄色的部分作了点修改，其他保持不变。
确实是类、接口减少了很多，而且程序也简单很多，但是大家可能还是很迷茫，这个 Client 程序并没有改变多少呀，非常正确，树的组装你是跑不了的，你要知道在项目中使用数据库来存储这些信息的，你从数据库中提出来哪些人要分配到树枝，哪些人要分配到树叶，树枝与树枝、树叶的关系，这些都需要人去定义，通常这里使用一个界面去配置，在数据库中是一个标志信息，例如定义这样一张表：
从这张表中已经定义个一个树形结构，我们要做的就是从数据库中读取出来，然后展现到前台上，这个读取就用个 for 循环加上递归是不是就可以把一棵树建立起来？我们程序中其实还包涵了数据的读取和加工，用了数据库后，数据和逻辑已经在表中定义好了，我们直接读取放到树上就可以了，这个还是比较容易做了的，大家不妨自己考虑一下。
上面我们讲到的就是组合模式（也叫合成模式），有时又叫做部分－整体模式（Part-Whole），主要是用来描述整体与部分的关系，用的最多的地方就是树形结构。组合模式通用类图如下：
我们先来说说组合模式的几个角色：
抽象构件角色(Component)： 定义参加组合的对象的共有方法和属性，可以定义一些默认的行为或属性；比如我们例子中的 getInfo 就封装到了抽象类中。
叶子构件（Leaf）：叶子对象，其下再也没有其他的分支。
树枝构件（Composite）：树枝对象，它的作用是组合树枝节点和叶子节点；
组合模式有两种模式，透明模式和安全模式，这两个模式有什么区别呢？先看类图：
从类图上大家应该能看清楚了，这两种模式各有优缺点，透明模式是把用来组合使用的方法放到抽象类中， 比如 add(),remove()以及 getChildren等方法（顺便说一下， getChildren 一般返回的结果为 Iterable的实现类，很多，大家可以看 JDK 的帮助），不管叶子对象还是树枝对象都有相同的结构，通过判断是getChildren 的返回值确认是叶子节点还是树枝节点，如果处理不当，这个会在运行期出现问题的，不是很建议的方式；安全模式就不同了，它是把树枝节点和树叶节点彻底分开，树枝节点单独拥有用来组合的方法，这种方法比较安全，我们的例子使用了安全模式。
组合模式的优点有哪些呢？第一个优点只要是树形结构，就要考虑使用组合模式，这个一定记住，只要是要体现局部和整体的关系的时候，而且这种关系还可能比较深，考虑一下组合模式吧。组合模式有一个非常明显的缺点，看到我们在 Client.java 中的的定义了树叶和树枝使用时的定义了吗？如下：
发现什么问题了吗？直接使用了实现类！这个在面向接口编程上是很不恰当的，这个在使用的时候要考虑清楚。
组合模式在项目中到处都有，比如现在的页面结构一般都是上下结构，上面放系统的 Logo，下边分为两部分：左边是导航菜单，右边是展示区，左边的导航菜单一般都是树形的结构，比较清晰， 这个 JavaScript有很多例子，大家可以到网上搜索一把；还有，我们的自己也是一个树状结构，根据我，能够找到我的父母，根据父亲又能找到爷爷奶奶，根据母亲能够找到外公外婆等等，很典型的树形结构，而且还很规范（这个要是不规范那肯定是乱套了）。
我们在上面也还提到了一个问题，就是树的遍历问题，从上到下遍历没有问题，但是我要是从下往上遍历呢？比如在人力资源这颗树上，我从中抽取一个用户，要找到它的上级有哪些，下级有哪些，怎么处理？想想，~~~，再想想！想出来了吧，我们对下答案，先看类图：
看类图中的红色方框，只要增加两个方法就可以了，一个是设置父节点是谁，一个是查找父节点是谁，我们来看一下程序的改变：
1 package com.pattern.composite.perfect;
2
3 /**
4 * 定义一个公司的人员的抽象类
5 * @author http://www.cnblogs.com/initial-road/
6 *
7 */
8 public abstract class Corp {
9
10 // 公司每个人都有名称
11 private String name = "";
12
13 // 公司每个人都有职位
14 private String position = "";
15
16 // 公司每个人都有薪水
17 private int salary = 0;
18
19 // 父节点是谁
20 protected Corp pattern = null;
21
22 /**
23 * 通过接口的方式传递，我们改变一下习惯，传递进来的变量名以下划线开始
24 * 这个在一些开源项目中非常常见，一般构造函数都是这么定义的
25 */
26 public Corp(String _name, String _position, int _salary){
27 this.name = _name;
28 this.position = _position;
29 this.salary = _salary;
30 }
31
32 // 获得员工信息
33 public String getInfo(){
34 String info = "";
35 info = "姓名：" + this.name;
36 info = info + "\t职位：" + this.position;
37 info = info + "\t薪水：" + this.salary;
38 return info;
39 }
40
41 // 得到父节点
42 public Corp getPattern() {
43 return pattern;
44 }
45
46 // 设置父节点
47 public void setPattern(Corp pattern) {
48 this.pattern = pattern;
49 }
50
51 }
52
53 // 就增加了父节点部分，然后我们再来看看 Branch.java 的改变：
54
55 package com.pattern.composite.perfect;
56
57 import java.util.ArrayList;
58
59 /**
60 * 节点类，也简单了很多
61 * @author http://www.cnblogs.com/initial-road/
62 *
63 */
64 public class Branch extends Corp {
65
66 // 领导下边有那些下级领导和小兵
67 ArrayList<Corp> subordinateList = new ArrayList<Corp>();
68
69 // 构造函数是必须的了
70 public Branch(String _name, String _position, int _salary) {
71 super(_name, _position, _salary);
72 }
73
74 // 增加一个下属，可能是小头目，也可能是个小兵
75 public void addSubordinate(Corp corp){
76 // 设置父节点
77 corp.setPattern(this);
78 this.subordinateList.add(corp);
79 }
80
81 // 我有哪些下属
82 public ArrayList<Corp> getSubordinate(){
83 return this.subordinateList;
84 }
85
86 }
增加了父节点部分，看懂程序了吗？就是在每个节点甭管是树枝节点还是树叶节点，都增加了一个属性：父节点对象，这样在树枝节点增加子节点或叶子的时候设置父节点，然后你看整棵树就除了根节点外每个节点都一个父节点，剩下的事情还不好处理吗？每个节点上都有父节点了，你要往上找，那就找呗！Client程序我就不写了，今天已经拷贝的代码实在有点多，大家自己考虑一下，写个 find 方法，然后一个一个往上找，最简单的方法了！
有了这个 parent 属性，什么后序遍历（从下往上找）、中序遍历（从中间某个环节往上或往下遍历）都解决了，这个就不多说了。
再提一个问题，树叶节点和树枝节点是有顺序的，你不能乱排的，怎么办？比如我们上面的例子，研发一组下边有三个成员，这三个成员是要进行排序的呀，你怎么处理？问我呀，问你呢，好好想想，以后用到着的！
