第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());                   }              }      } } 这个程序比较长，如果在我们的项目中有这样的程序，肯定是要被拉出来做典型的，你写一大坨的程序给谁呀，以后还要维护，程序要短小精悍！幸运的是，我们这是作为案例来讲解，而且就是指出这样组装这棵树是有问题的，等会我们深入讲解，先看运行结果：   | 名称：王大麻子 | 　职位：总经理 | 　薪水: 100000 | |-----|-----|-----| | 名称：刘大瘸子 | 　职位：研发部门经理 | 　薪水：10000 | | 名称：杨三乜斜 | 　职位：开发一组组长 | 　薪水：5000 | | 名称：a | 　职位：开发人员 | 　薪水：2000 | | 名称：b | 　职位：开发人员 | 　薪水：2000 | | 名称：c | 　职位：开发人员 | 　薪水：2000 | | 名称：吴大棒槌 | 　职位：开发二组组长 | 　薪水：6000 | | 名称：d | 　职位：开发人员 | 　薪水：2000 | | 名称：e | 　职位：开发人员 | 　薪水：2000 | | 名称：f | 　职位：开发人员 | 　薪水：2000 | | 名称：郑老六 | 　职位：研发部副总 | 　薪水：20000 | | 名称：马二拐子 | 　职位：销售部门经理 | 　薪水：20000 | | 名称：h | 　职位：销售人员 | 　薪水：5000 | | 名称：i | 　职位：销售人员 | 　薪水：4000 | | 名称：赵三驼子 | 　职位：财务部经理 | 　薪水：30000 | | 名称：j | 　职位：财务人员 | 　薪水：5000 | | 名称：k | 　职位：CEO秘书 | 　薪水：8000 | 和我们期望的结果一样，一棵完整的树就生成了，而且我们还能够遍历。不错，不错，但是看类图或程序的时候，你有没有发觉有问题？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抽象类，仅仅修改了粗体部分，其他保持不变，运行结果相同。这就是组合模式。