《设计模式之禅（第2版）》第21章 组合模式

21.1 公司的人事架构是这样的吗

各位读者，大家在上学的时候应该都学过“数据结构”这门课程吧，还记得其中有一节叫“二叉树”吧，我们上学那会儿这一章节是必考内容，左子树，右子树，什么先序遍历、后序遍历，重点就是二叉树的遍历，我还记得当时老师就说，考试的时候一定有二叉树的构建和遍历，现在想起来还是觉得老师是正确的，树状结构在实际中应用非常广泛，想想看你最常使用的XML格式是不是就是一个树形结构。

咱就先说个最常见的例子，公司的人事管理就是一个典型的树状结构，想想看你公司的组织架构是不是如图21-1所示。

图21-1 普遍的组织架构

从最高的老大，往下一层一层的管理，最后到我们这层小兵……很典型的树状结构（说明一下，这不是二叉树，有关二叉树的定义可以翻翻以前的教科书），我们今天的任务就是要把这个树状结构实现出来，并且还要把它遍历一遍，就类似于阅读你公司的人员花名册。

从该树状结构上分析，有两种不同性质的节点：有分支的节点（如研发部经理）和无分支的节点（如员工A、员工D等），我们增加一点学术术语上去，总经理叫做根节点(是不是想到XML中的那个根节点root，那就对了)，类似研发部经理有分支的节点叫做树枝节点，类似员工A的无分支的节点叫做树叶节点，都很形象，三个类型的节点，那是不是定义三个类就可以？好，我们按照这个思路走下去，先看我们自己设计的类图，如图21-2所示。

图21-2 最容易想到的组织架构类图

这个类图是初学者最容易想到的类图（首先声明，这个类图是有缺陷的，如果你已经看明白这个类图的缺陷了，该段落就可以一目十行地看下去，我们是循序渐进地讲课，一步一个脚印），非常简单，我们来看一下如何实现，先看最高级别的根节点接口，如代码清单21-1所示。

代码清单21-1 根节点接口

public interface IRoot {     //得到总经理的信息     public String getInfo;     //总经理下边要有小兵，那要能增加小兵，比如研发部总经理，这是个树枝节点     public void add(IBranch branch);     //那要能增加树叶节点     public void add(ILeaf leaf);     //既然能增加，那还要能够遍历，不可能总经理不知道他手下有哪些人     public ArrayList getSubordinateInfo;     }  

这个根节点的对象就是我们的总经理，其具体实现如代码清单21-2所示。

代码清单21-2 根节点的实现

public class Root implements IRoot {     //保存根节点下的树枝节点和树叶节点，Subordinate的意思是下级     private ArrayList subordinateList = new ArrayList;     //根节点的名称     private String name = "";     //根节点的职位     private String position = "";     //根节点的薪水     private int salary = 0;     //通过构造函数传递进来总经理的信息     public Root(String name,String position,int salary){     this.name = name;     this.position = position;     this.salary = salary;     }     //增加树枝节点     public void add(IBranch branch) {     this.subordinateList.add(branch);     }     //增加叶子节点，比如秘书，直接隶属于总经理     public void add(ILeaf leaf) {     this.subordinateList.add(leaf);     }     //得到自己的信息     public String getInfo {     String info = "";     info = "名称："+ this.name;;     info = info + "/t职位：" + this.position;     info = info + "/t薪水： " + this.salary;     return info;     }     //得到下级的信息     public ArrayList getSubordinateInfo {     return this.subordinateList;     }}  

很简单，通过构造函数传入参数，然后获得信息，可以增加子树枝节点（部门经理）和叶子节点（秘书）。我们再来看其他有分支的节点接口，如代码清单21-3所示。

代码清单21-3 其他有分支的节点接口

public interface IBranch {     //获得信息     public String getInfo;     //增加数据节点，例如研发部下设的研发一组     public void add(IBranch branch);     //增加叶子节点     public void add(ILeaf leaf);     //获得下级信息     public ArrayList getSubordinateInfo;}  

有了接口，就应该有实现，其具体的实现类，如代码清单21-4所示。

代码清单21-4 分支的节点实现

public class Branch implements IBranch {     //存储子节点的信息     private ArrayList subordinateList = new ArrayList;     //树枝节点的名称     private String name="";     //树枝节点的职位     private String position = "";     //树枝节点的薪水     private int salary = 0;     //通过构造函数传递树枝节点的参数     public Branch(String name,String position,int salary){     this.name = name;     this.position = position;     this.salary = salary;     }     //增加一个子树枝节点     public void add(IBranch branch) {     this.subordinateList.add(branch);     }     //增加一个叶子节点     public void add(ILeaf leaf) {     this.subordinateList.add(leaf);     }     //获得自己树枝节点的信息     public String getInfo {     String info = "";     info = "名称：" + this.name;     info = info + "/t职位："+ this.position;     info = info + "/t薪水："+this.salary;     return info;     }     //获得下级的信息     public ArrayList getSubordinateInfo {     return this.subordinateList;     }}  

不管是总经理还是部门经理都是有子节点的存在，最终的子节点就是叶子节点，其接口如代码清单21-5所示。

代码清单21-5 叶子节点的接口

public interface ILeaf {//获得自己的信息     public String getInfo;}  

叶子节点的接口简单，实现也非常容易，如代码清单21-6所示。

代码清单21-6 叶子节点的实现

public class Leaf implements ILeaf {     //叶子叫什么名字     private String name = "";     //叶子的职位     private String position = "";     //叶子的薪水     private int salary=0;     //通过构造函数传递信息     public Leaf(String name,String position,int salary){     this.name = name;     this.position = position;     this.salary = salary;     }     //最小的小兵只能获得自己的信息了     public String getInfo {     String info = "";     info = "名称：" + this.name;     info = info + "/t职位："+ this.position;     info = info + "/t薪水："+this.salary;     return info;     }}  

好了，所有的根节点、树枝节点和叶子节点都已经实现了，从总经理、部门经理到最终的员工都已经实现，然后的工作就是组装成一个树状结构并遍历这棵树，通过什么来完成呢？通过场景类Client完成，如代码清单21-7所示。

代码清单21-7 场景类

public class Client {     public static void main(String args) {     //首先产生了一个根节点     IRoot ceo = new Root("王大麻子","总经理",100000);     //产生三个部门经理，也就是树枝节点     IBranch developDep = new Branch("刘大瘸子","研发部门经理",10000);     IBranch salesDep = new Branch("马二拐子","销售部门经理",20000);     IBranch financeDep = new Branch("赵三驼子","财务部经理",30000);     //再把三个小组长产生出来     IBranch firstDevGroup = new Branch("杨三乜斜","开发一组组长",5000);     IBranch secondDevGroup = new Branch("吴大棒槌","开发二组组长",6000);     //剩下的就是我们这些小兵了,就是路人甲、路人乙     ILeaf a = new Leaf("a","开发人员",2000);     ILeaf b = new Leaf("b","开发人员",2000);     ILeaf c = new Leaf("c","开发人员",2000);     ILeaf d = new Leaf("d","开发人员",2000);     ILeaf e = new Leaf("e","开发人员",2000);     ILeaf f = new Leaf("f","开发人员",2000);     ILeaf g = new Leaf("g","开发人员",2000);     ILeaf h = new Leaf("h","销售人员",5000);     ILeaf i = new Leaf("i","销售人员",4000);     ILeaf j = new Leaf("j","财务人员",5000);     ILeaf k = new Leaf("k","CEO秘书",8000);     ILeaf zhengLaoLiu = new Leaf("郑老六","研发部副总",20000);     //该产生的人都产生出来了，然后我们怎么组装这棵树     //首先是定义总经理下有三个部门经理     ceo.add(developDep);     ceo.add(salesDep);     ceo.add(financeDep);     //总经理下还有一个秘书     ceo.add(k);     //定义研发部门下的结构     developDep.add(firstDevGroup);     developDep.add(secondDevGroup);     //研发部经理下还有一个副总     developDep.add(zhengLaoLiu);     //看看开发两个开发小组下有什么     firstDevGroup.add(a);     firstDevGroup.add(b);     firstDevGroup.add(c);     secondDevGroup.add(d);     secondDevGroup.add(e);     secondDevGroup.add(f);     //再看销售部下的人员情况     salesDep.add(h);     salesDep.add(i);     //最后一个财务     financeDep.add(j);     //打印写完的树状结构     System.out.println(ceo.getInfo);     //打印出来整个树形     getAllSubordinateInfo(ceo.getSubordinateInfo);     }     //遍历所有的树枝节点，打印出信息     private static void getAllSubordinateInfo(ArrayList subordinateList){     int length = subordinateList.size;     //定义一个ArrayList长度，不要在for循环中每次计算     for(int m=0;m<length;m++){    Object s = subordinateList.get(m);  if(s instanceof Leaf){  //是个叶子节点，也就是员工  ILeaf employee = (ILeaf)s;  System.out.println(((Leaf) s).getInfo);  }else{  IBranch branch = (IBranch)s;  System.out.println(branch.getInfo);  //再递归调用  getAllSubordinateInfo(branch.getSubordinateInfo);  }     }     }}  

这个程序比较长，如果在我们的项目中有这样的程序，肯定是要被拉出来做典型的，你写一大坨的程序给谁呀，以后还要维护，程序要短小精悍！幸运的是，我们这是作为案例来讲解，而且就是指出这样组装这棵树是有问题的，等会我们深入讲解，先看运行结果：

和我们期望的结果一样，一棵完整的树就生成了，而且我们还能够遍历。不错，不错，但是看类图或程序的时候，你有没有发觉有问题？getInfo每个接口都有，为什么不能抽象出来？Root类和Branch类有什么差别？根节点本身就是树枝节点的一种，为什么要定义成两个接口两个类?如果我要加一个任职期限，你是不是每个类都需要修改？如果我要后序遍历（从员工找到他的上级领导）能做到吗？——彻底晕菜了！

问题很多，我们一个一个解决，先说抽象的问题。我们确实可以把IBranch和IRoot合并成一个接口，确认无疑的事我们先做，那我们就修改一下类图，如图21-3所示。

仔细看看这个类图，还能不能发现点问题。想想看接口的作用是什么？定义一类事物所具有的共性，那ILeaf和IBranch是不是也有共性呢？有，getInfo方法！我们是不是要把这个共性也封装起来呢？是的，是的，提炼事物的共同点，然后封装之，这是我们作为设计专家的拿手好戏，修改后的类图如图21-4所示。

图21-3 整合根节点和树枝节点后的类图

图21-4 修改后的类图

类图上增加了一个ICorp接口，它是公司所有人员信息的接口类，不管你是经理还是员工，你都有名字、职位、薪水，这个定义成一个接口没有错，但是你可能对于ILeaf接口持怀疑状态，空接口有何意义呀？有意义！它是每个树枝节点的代表，系统扩容的时候你就会发现它是多么“栋梁”。我们先来看新增加的接口ICorp，如代码清单21-8所示。

代码清单21-8 公司人员接口

public interface ICorp {     //每个员工都有信息，你想隐藏，门儿都没有！     public String getInfo;}  

接口很简单，只有一个方法，就是获得员工的信息，树叶节点是最基层的构件，我们先来看看它的接口，空接口，如代码清单21-9所示。

代码清单21-9 树叶接口

public interface ILeaf extends ICorp {}  

树叶接口的实现类，如代码清单21-10所示。

代码清单21-10 树叶接口

public class Leaf implements ILeaf {     //小兵也有名称     private String name = "";     //小兵也有职位     private String position = "";     //小兵也有薪水，否则谁给你干     private int salary = 0;     //通过一个构造函数传递小兵的信息     public Leaf(String name,String position,int salary){     this.name = name;     this.position = position;     this.salary = salary;     }     //获得小兵的信息     public String getInfo {     String info = "";     info = "姓名：" + this.name;     info = info + "/t职位："+ this.position;     info = info + "/t薪水：" + this.salary;     return info;     }}  

小兵就只有这些信息了，我们是具体干活的，我们是管理不了其他同事的，我们来看看那些经理和小组长是怎么实现的，也就是IBranch接口，如代码清单21-11所示。

代码清单21-11 树枝接口

public interface IBranch extends ICorp {//能够增加小兵（树叶节点）或者是经理（树枝节点）     public void addSubordinate(ICorp corp);     //我还要能够获得下属的信息     public ArrayList<ICorp> getSubordinate;     /*本来还应该有一个方法delSubordinate(ICorp corp)，删除下属      * 这个方法我们没有用到就不写进来了      */}  

接口也很简单，其实现类也不可能太复杂，如代码清单21-12所示。

代码清单21-12 树枝实现类

public class Branch implements IBranch {     //领导也是人，也有名字     private String name = "";     //领导和领导不同，也是职位区别     private String position = "";     //领导也是拿薪水的     private int salary = 0;     //领导下边有哪些下级领导和小兵     ArrayList<ICorp> subordinateList = new ArrayList<ICorp>;     //通过构造函数传递领导的信息     public Branch(String name,String position,int salary){     this.name = name;     this.position = position;     this.salary = salary;     }     //增加一个下属，可能是小头目，也可能是个小兵     public void addSubordinate(ICorp corp) {     this.subordinateList.add(corp);     }     //我有哪些下属     public ArrayList<ICorp> getSubordinate {     return this.subordinateList;     }     //领导也是人，他也有信息     public String getInfo {     String info = "";     info = "姓名：" + this.name;     info = info + "/t职位："+ this.position;     info = info + "/t薪水：" + this.salary;     return info;     }}  

实现类也很简单，不多说，程序写得好不好，就看别人怎么调用了，我们看场景类Client，如代码清单21-13所示。

代码清单21-13 场景类a

public class Client {     public static void main(String args) {     //首先是组装一个组织结构出来     Branch ceo = compositeCorpTree;     //首先把CEO的信息打印出来     System.out.println(ceo.getInfo);     //然后是所有员工信息     System.out.println(getTreeInfo(ceo));     }     //把整个树组装出来     public static Branch compositeCorpTree{     //首先产生总经理CEO     Branch root = new Branch("王大麻子","总经理",100000);     //把三个部门经理产生出来     Branch developDep = new Branch("刘大瘸子","研发部门经理",10000);     Branch salesDep = new Branch("马二拐子","销售部门经理",20000);     Branch financeDep = new Branch("赵三驼子","财务部经理",30000);     //再把三个小组长产生出来     Branch firstDevGroup = new Branch("杨三乜斜","开发一组组长",5000);     Branch secondDevGroup = new Branch("吴大棒槌","开发二组组长",6000);     //把所有的小兵都产生出来     Leaf a = new Leaf("a","开发人员",2000);     Leaf b = new Leaf("b","开发人员",2000);     Leaf c = new Leaf("c","开发人员",2000);     Leaf d = new Leaf("d","开发人员",2000);     Leaf e = new Leaf("e","开发人员",2000);     Leaf f = new Leaf("f","开发人员",2000);     Leaf g = new Leaf("g","开发人员",2000);     Leaf h = new Leaf("h","销售人员",5000);     Leaf i = new Leaf("i","销售人员",4000);     Leaf j = new Leaf("j","财务人员",5000);     Leaf k = new Leaf("k","CEO秘书",8000);     Leaf zhengLaoLiu = new Leaf("郑老六","研发部副经理",20000);     //开始组装     //CEO下有三个部门经理和一个秘书     root.addSubordinate(k);     root.addSubordinate(developDep);     root.addSubordinate(salesDep);     root.addSubordinate(financeDep);     //研发部经理     developDep.addSubordinate(zhengLaoLiu);     developDep.addSubordinate(firstDevGroup);     developDep.addSubordinate(secondDevGroup);     //看看两个开发小组下有什么     firstDevGroup.addSubordinate(a);     firstDevGroup.addSubordinate(b);     firstDevGroup.addSubordinate(c);     secondDevGroup.addSubordinate(d);     secondDevGroup.addSubordinate(e);     secondDevGroup.addSubordinate(f);     //再看销售部下的人员情况     salesDep.addSubordinate(h);     salesDep.addSubordinate(i);     //最后一个财务     financeDep.addSubordinate(j);     return root;     }     //遍历整棵树,只要给我根节点，我就能遍历出所有的节点     public static String getTreeInfo(Branch root){     ArrayList<ICorp> subordinateList = root.getSubordinate;     String info = "";     for(ICorp s :subordinateList){     if(s instanceof Leaf){ //是员工就直接获得信息     info = info + s.getInfo+"/n";     }else{ //是个小头目     info = info + s.getInfo +"/n"+ getTreeInfo((Branch)s);     }     }     return info;     }} 

运行结果完全相同，不再赘述。通过这样构件，一个非常清晰的树状人员资源管理图出现了，那我们的程序是否还可以优化？可以！你看Leaf和Branch中都有getInfo信息，是不是可以抽象？好，我们抽象一下，如图21-5所示。

图21-5 精简的类图

你一看这个图，乐了。能不乐嘛，减少很多工作量了，接口没有了，改成抽象类了，IBranch接口也没有了，直接把方法放到了实现类中了，太精简了！而且场景类只认定抽象类Corp就成，那我们首先来看抽象类ICorp，如代码清单21-14所示。

代码清单21-14 抽象公司职员类

public abstract class Corp {     //公司每个人都有名称     private String name = "";     //公司每个人都职位     private String position = "";     //公司每个人都有薪水     private int salary =0;public Corp(String _name,String _position,int _salary){     this.name = _name;     this.position = _position;     this.salary = _salary;     }     //获得员工信息     public String getInfo{     String info = "";     info = "姓名：" + this.name;     info = info + "/t职位："+ this.position;     info = info + "/t薪水：" + this.salary;     return info;     }}  

抽象类嘛，就应该抽象出一些共性的东西出来，然后看两个具体的实现类，树叶节点如代码清单21-15所示。

代码清单21-15 树叶节点

public class Leaf extends Corp {     //就写一个构造函数，这个是必需的     public Leaf(String _name,String _position,int _salary){     super(_name,_position,_salary);     }}  

这个精简得比较多，几行代码就完成了，确实就应该这样，下面是小头目的实现类，如代码清单21-16所示。

代码清单21-16 树枝节点

public class Branch extends Corp {     //领导下边有哪些下级领导和小兵     ArrayList<Corp> subordinateList = new ArrayList<Corp>;     //构造函数是必需的     public Branch(String _name,String _position,int _salary){     super(_name,_position,_salary);     }     //增加一个下属，可能是小头目，也可能是个小兵     public void addSubordinate(Corp corp) {     this.subordinateList.add(corp);     }     //我有哪些下属     public ArrayList<Corp> getSubordinate {     return this.subordinateList;     }}  

场景类中构建树形结构，并进行遍历。组装没有变化，遍历组织机构数稍有变化，如代码清单21-17所示。

代码清单21-17 稍稍修改的场景类

public class Client {     //遍历整棵树,只要给我根节点，我就能遍历出所有的节点     public static String getTreeInfo(Branch root){     ArrayList<Corp> subordinateList = root.getSubordinate;     String info = "";     for(Corp s :subordinateList){    if(s instanceof Leaf){ //是员工就直接获得信息   info = info + s.getInfo+"/n";    }else{ //是个小头目   info = info+s.getInfo+"/n"+ getTreeInfo((Branch)s);    }     }     return info;     }}  

场景类中main方法没有变动，请参考代码清单21-7所示，不再赘述。遍历组织机构树的getTreeInfo稍有修改，就是把用到ICorp接口的地方修改为Corp抽象类，仅仅修改了粗体部分，其他保持不变，运行结果相同。这就是组合模式。