您的设计模式——组合模式【Composite Pattern 】

怼烎@ 2022-06-18 05:24 211阅读 0赞

大家在上学的时候应该都学过“数据结构”这门课程吧，还记得其中有一节叫“二叉树”吧，我们上  
学那会儿这一章节是必考内容，左子树，右子树，什么先序遍历后序遍历什么，重点就是二叉树的的遍历，  
我还记得当时老师就说，考试的时候一定有二叉树的构建和遍历，现在想起来还是觉的老师是正确的，树  
状结果在实际项目应用的非常广泛。  
咱就先说个最常见的例子，公司的人事管理就是一个典型的树状结构，你想想你公司的结构是不是这  
样:

![这里写图片描述][SouthEast]

从 最 高 的老大，往下一层一层的管理，最后到我们这层小兵，很典型的树状结构（说明一下，这不是二叉树，有关二叉树的定义可以翻翻以前的教科书） ，我们今天的任务就是要把这个树状结构实现出来，并且还要把它遍历一遍，你要确认你建立的树是否有问题呀。  
从这个树状结构上分析，有两种节点：有分支的节点（如研发部经理）和无分支的节点（如员工 A、员  
工 D 等） ，我们增加一点学术术语上去，总经理叫做根节点(是不是想到 XML 中的那个根节点 root，那就对  
了)，类似研发部经理有分支的节点叫做树枝节点，类似员工 A 的无分支的节点叫做树叶节点，都很形象，  
三个类型的的节点，那是不是定义三个类就可以？好，我们按照这个思路走下去，先看我们自己设计的类  
图：

![这里写图片描述][SouthEast 1]

这个类图是初学者最容易想到的类图（如果你已经看明白这个类图的缺陷了，就可以不看下边的实现  
了，我是循序渐进的讲课，呵呵） ，我那来看这个实现：  
先看最高级别的根节点的实现：

package com.alex.patterns.composite;

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

这个根节点就是我们的总经理 CEO，然后看实现类：

package com.alex.patterns.composite;
    
    import java.util.ArrayList;
    
    /** * @author Alex * 根节点的实现类 */
    @SuppressWarnings("all")
    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;
        }
    }

很简单，通过构造函数传入参数，然后获得信息，还可以增加子树枝节点（部门经理）和叶子节点（秘  
书） 。我们再来看 IBranch.java:

package com.alex.patterns.composite;
    
    import java.util.ArrayList;
    
    /** * @author Alex * 树枝节点，也就是各个部门经理和组长的角色 */
    public interface IBranch { 
        // 获得信息
        public String getInfo();
    
        // 增加数据节点，例如研发部下的研发一组
        public void add(IBranch branch);
    
        // 增加叶子节点
        public void add(ILeaf leaf);
    
        // 获得下级信息
        public ArrayList getSubordinateInfo();
    }

下面是树枝节点的实现类：

package com.alex.patterns.composite;
    
    import java.util.ArrayList;
    
    /** * @author Alex * 所有的树枝节点 */
    @SuppressWarnings("all")
    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;
        }
    }

最后看叶子节点，也就是员工的接口：

package com.alex.patterns.composite;
    
    /** * @author Alex * 叶子节点，也就是最小的小兵了，只能自己干活，不能指派别人了 */
    public interface ILeaf { 
        // 获得自己的信息呀
        public String getInfo();
    }

下面是叶子节点的实现类：

package com.alex.patterns.composite;
    
    /** * @author Alex * 最小的叶子节点 */
    @SuppressWarnings("all")
    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.java 程序：

package com.alex.patterns.composite;
    
    import java.util.ArrayList;
    
    /** * @author Alex * Client的作用是组装这棵树，并遍历一遍 */
    @SuppressWarnings("all")
    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();
            for (int m = 0; m < length; m++) { // 定义一个ArrayList长度，不要在for循环中每次计算
                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 合并成一个接口，这  
个我们先肯定下来，这是个比较大的改动，我们先画个类图：

![这里写图片描述][SouthEast 2]

这个类图还是有点问题的，接口的作用是什么？定义共性，那 ILeaf 和 IBranch 是不是也有共性呢？  
有 getInfo（） ，我们是不是要把这个共性也已经封装起来呢？好，我们再修改一下类图：

![这里写图片描述][SouthEast 3]

类图上有两个接口，ICorp 是公司所有人员的信息的接口类，不管你是经理还是员工，你都有名字，职  
位，薪水，这个定义成一个接口没有错，IBranch 有没有必要呢？我们先实现出来然后再说。  
先看 ICorp.java 源代码：

package com.alex.patterns.composite;
    
    /** * @author Alex * 公司类，定义每个员工都有信息 */
    public interface ICorp { 
        // 每个员工都有信息，你想隐藏，门儿都没有！
        public String getInfo();
    }

接口很简单，只有一个方法，就是获得员工的信息，我们再来看实现类：

package com.alex.patterns.composite;
    
    /** * @author Alex * Leaf1是树叶节点，在这里就是我们这些小兵 */
    @SuppressWarnings("all")
    public class Leaf1 implements ICorp { 
        // 小兵也有名称
        private String name = "";
        // 小兵也有职位
        private String position = "";
        // 小兵也有薪水，否则谁给你干
        private int salary = 0;
    
        // 通过一个构造函数传递小兵的信息
        public Leaf1(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;
        }
    }

小兵就只有这些信息了，我们是具体干活的，我们是管理不了其他同事的，我们来看看那些经理和小  
组长是怎么实现的，先看接口：

package com.alex.patterns.composite;
    
    import java.util.ArrayList;
    
    /** * @author Alex * 这些下边有小兵或者是经理等风云人物 */
    public interface IBranch1 { 
        // 能够增加小兵(树叶节点）或者是经理（树枝节点）
        public void addSubordinate(ICorp corp);
    
        // 我还要能够获得下属的信息
        public ArrayList<ICorp> getSubordinate();
        /* * 本来还应该有一个方法delSubordinate(ICorp corp)，删除下属 这个方法我们没有用到就不写进来了 */
    }

接口也是很简单的，下面是实现类：

package com.alex.patterns.composite;
    
    import java.util.ArrayList;
    
    /** * @author Alex * 这些树枝节点也就是这些领导们既要有自己的信息，还要知道自己的下属情况 */
    @SuppressWarnings("all")
    public class Branch1 implements IBranch1, ICorp { 
        // 领导也是人，也有名字
        private String name = "";
        // 领导和领导不同，也是职位区别
        private String position = "";
        // 领导也是拿薪水的
        private int salary = 0;
        // 领导下边有那些下级领导和小兵
        ArrayList<ICorp> subordinateList = new ArrayList<ICorp>();
    
        // 通过构造函数传递领导的信息
        public Branch1(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;
        }
    }

实现类也很简单，不多说，程序写的好不好，就看别人怎么调用了，我们看 Client1.java 程序：

package com.alex.patterns.composite;
    
    import java.util.ArrayList;
    
    /** * @author Alex * 组装这个树形结构，并展示出来 */
    @SuppressWarnings("all")
    public class Client1 { 
        public static void main(String[] args) {
            // 首先是组装一个组织结构出来
            Branch1 ceo = compositeCorpTree();
            // 首先把CEO的信息打印出来：
            System.out.println(ceo.getInfo());
            // 然后是所有员工信息
            System.out.println(getTreeInfo(ceo));
        }
    
        // 把整个树组装出来
        public static Branch1 compositeCorpTree() {
            // 首先产生总经理CEO
            Branch1 root = new Branch1("王大麻子", "总经理", 100000);
            // 把三个部门经理产生出来
            Branch1 developDep = new Branch1("刘大瘸子", "研发部门经理", 10000);
            Branch1 salesDep = new Branch1("马二拐子", "销售部门经理", 20000);
            Branch1 financeDep = new Branch1("赵三驼子", "财务部经理", 30000);
            // 再把三个小组长产生出来
            Branch1 firstDevGroup = new Branch1("杨三乜斜", "开发一组组长", 5000);
            Branch1 secondDevGroup = new Branch1("吴大棒槌", "开发二组组长", 6000);
            // 把所有的小兵都产生出来
            Leaf1 a = new Leaf1("a", "开发人员", 2000);
            Leaf1 b = new Leaf1("b", "开发人员", 2000);
            Leaf1 c = new Leaf1("c", "开发人员", 2000);
            Leaf1 d = new Leaf1("d", "开发人员", 2000);
            Leaf1 e = new Leaf1("e", "开发人员", 2000);
            Leaf1 f = new Leaf1("f", "开发人员", 2000);
            Leaf1 g = new Leaf1("g", "开发人员", 2000);
            Leaf1 h = new Leaf1("h", "销售人员", 5000);
            Leaf1 i = new Leaf1("i", "销售人员", 4000);
            Leaf1 j = new Leaf1("j", "财务人员", 5000);
            Leaf1 k = new Leaf1("k", "CEO秘书", 8000);
            Leaf1 zhengLaoLiu = new Leaf1("郑老六", "研发部副经理", 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(Branch1 root) {
            ArrayList<ICorp> subordinateList = root.getSubordinate();
            String info = "";
            for (ICorp s : subordinateList) {
                if (s instanceof Leaf1) { // 是员工就直接获得信息
                    info = info + s.getInfo() + "\n";
                } else { // 是个小头目
                    info = info + s.getInfo() + "\n" + getTreeInfo((Branch1) s);
                }
            }
            return info;
        }
    }

一个非常清理的树状人员资源管理图出现了， 那我们的程序是否还可以优化？可以！ 你看Leaf和Branch  
中都有 getInfo 信息，是否可以抽象，好，我们抽象一下：

![这里写图片描述][SouthEast 4]

你一看这个图，乐了，能不乐嘛，减少很多工作量了，接口没有了，改成抽象类了，IBranch 接口也没  
有了，直接把方法放到了实现类中了，那我们先来看抽象类：

package com.alex.patterns.composite;
    
    /** * @author Alex * 定义一个公司的人员的抽象类 */
    @SuppressWarnings("all")
    public abstract class Corp2 { 
        // 公司每个人都有名称
        private String name = "";
        // 公司每个人都职位
        private String position = "";
        // 公司每个人都有薪水
        private int salary = 0;
    
        /* * 通过接口的方式传递，我们改变一下习惯，传递进来的参数名以下划线开始 这个在一些开源项目中非常常见，一般构造函数都是这么定义的 */
        public Corp2(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;
        }
    }

抽象类嘛，就应该抽象出一些共性的东西出来，然后看两个具体的实现类：

package com.alex.patterns.composite;
    
    /** * @author Alex * 普通员工很简单，就写一个构造函数就可以了 */
    public class Leaf2 extends Corp2 { 
        // 就写一个构造函数，这个是必须的
        public Leaf2(String _name, String _position, int _salary) {
            super(_name, _position, _salary);
        }
    }

这个改动比较多，就几行代码就完成了，确实就应该这样，下面是小头目的实现类：

package com.alex.patterns.composite;
    import java.util.ArrayList;
    /** * @author Alex * 节点类，也简单了很多 */
    public class Branch2 extends Corp2 { 
        //领导下边有那些下级领导和小兵
        ArrayList<Corp2> subordinateList = new ArrayList<Corp2>();
        //构造函数是必须的了
        public Branch2(String _name,String _position,int _salary){
            super(_name,_position,_salary);
        }
        //增加一个下属，可能是小头目，也可能是个小兵
        public void addSubordinate(Corp2 Corp2) {
            this.subordinateList.add(Corp2);
        }
        //我有哪些下属
        public ArrayList<Corp2> getSubordinate() {
            return this.subordinateList;
        }
    }

也缩减了很多，再看 Client2.java 程序，这个就没有多大变化了：

package com.alex.patterns.composite;
    
    import java.util.ArrayList;
    
    /** * @author Alex * 组装这个树形结构，并展示出来 */
    @SuppressWarnings("all")
    public class Client2 { 
        public static void main(String[] args) {
            // 首先是组装一个组织结构出来
            Branch2 ceo = compositeCorp2Tree();
            // 首先把CEO的信息打印出来：
            System.out.println(ceo.getInfo());
            // 然后是所有员工信息
            System.out.println(getTreeInfo(ceo));
        }
    
        // 把整个树组装出来
        public static Branch2 compositeCorp2Tree() {
            // 首先产生总经理CEO
            Branch2 root = new Branch2("王大麻子", "总经理", 100000);
            // 把三个部门经理产生出来
            Branch2 developDep = new Branch2("刘大瘸子", "研发部门经理", 10000);
            Branch2 salesDep = new Branch2("马二拐子", "销售部门经理", 20000);
            Branch2 financeDep = new Branch2("赵三驼子", "财务部经理", 30000);
            // 再把三个小组长产生出来
            Branch2 firstDevGroup = new Branch2("杨三乜斜", "开发一组组长", 5000);
            Branch2 secondDevGroup = new Branch2("吴大棒槌", "开发二组组长", 6000);
            // 把所有的小兵都产生出来
            Leaf2 a = new Leaf2("a", "开发人员", 2000);
            Leaf2 b = new Leaf2("b", "开发人员", 2000);
            Leaf2 c = new Leaf2("c", "开发人员", 2000);
            Leaf2 d = new Leaf2("d", "开发人员", 2000);
            Leaf2 e = new Leaf2("e", "开发人员", 2000);
            Leaf2 f = new Leaf2("f", "开发人员", 2000);
            Leaf2 g = new Leaf2("g", "开发人员", 2000);
            Leaf2 h = new Leaf2("h", "销售人员", 5000);
            Leaf2 i = new Leaf2("i", "销售人员", 4000);
            Leaf2 j = new Leaf2("j", "财务人员", 5000);
            Leaf2 k = new Leaf2("k", "CEO秘书", 8000);
            Leaf2 zhengLaoLiu = new Leaf2("郑老六", "研发部副经理", 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(Branch2 root) {
            //注意
            ArrayList<Corp2> subordinateList = root.getSubordinate();
            String info = "";
            for (Corp2 s : subordinateList) {
            //注意
                if (s instanceof Leaf2) { // 是员工就直接获得信息
                    info = info + s.getInfo() + "\n";
                } else { // 是个小头目
                    info = info + s.getInfo() + "\n" + getTreeInfo((Branch2) s);
                }
            }
            return info;
        }
    }

就是把用到 ICorp 接口的地方修改为 Corp 抽象类就成了，就上面注意的部分作了点修改，其他保持不变。

确实是类、接口减少了很多，而且程序也简单很多，但是大家可能还是很迷茫，这个 Client 程序并没  
有改变多少呀，非常正确，树的组装你是跑不了的，你要知道在项目中使用数据库来存储这些信息的，你  
从数据库中提出出来哪些人要分配到树枝，哪些人要分配到树叶，树枝与树枝、树叶的关系，这些都需要  
人去定义，通常这里使用一个界面去配置，在数据库中是一个标志信息，例如定义这样一张表：

![这里写图片描述][SouthEast 5]

从这张表中已经定义个一个树形结构，我们要做的就是从数据库中读取出来，然后展现到前台上，这  
个读取就用个 for 循环加上递归是不是就可以把一棵树建立起来？我们程序中其实还包涵了数据的读取和  
加工，用了数据库后，数据和逻辑已经在表中定义好了，我们直接读取放到树上就可以了，这个还是比较  
容易做了的，大家不妨自己考虑一下。  
上面我们讲到的就是组合模式（也叫合成模式） ，有时又叫做部分－整体模式（Part-Whole） ，主要是  
用来描述整体与部分的关系，用的最多的地方就是树形结构。组合模式通用类图如下：

![这里写图片描述][SouthEast 6]

我们先来说说组合模式的几个角色：  
抽象构件角色(Component)： 定义参加组合的对象的共有方法和属性， 可以定义一些默认的行为或属性；  
比如我们例子中的 getInfo 就封装到了抽象类中。  
叶子构件（Leaf） ：叶子对象，其下再也没有其他的分支。  
树枝构件（Composite） ：树枝对象，它的作用是组合树枝节点和叶子节点；  
组合模式有两种模式，透明模式和安全模式，这两个模式有什么区别呢？先看类图：

![这里写图片描述][SouthEast 7]

![这里写图片描述][SouthEast 8]

从类图上大家应该能看清楚了，这两种模式各有优缺点，透明模式是把用来组合使用的方法放到抽象  
类中， 比如add(),remove()以及getChildren等方法 （顺便说一下， getChildren一般返回的结果为Iterable  
的实现类，很多，大家可以看 JDK 的帮助） ，不管叶子对象还是树枝对象都有相同的结构，通过判断是  
getChildren 的返回值确认是叶子节点还是树枝节点，如果处理不当，这个会在运行期出现问题的，不是很  
建议的方式；安全模式就不同了，它是把树枝节点和树叶节点彻底分开，树枝节点单独拥有用来组合的方  
法，这种方法比较安全，我们的例子使用了安全模式。  
组合模式的优点有哪些呢？第一个优点只要是树形结构，就要考虑使用组合模式，这个一定记住，只  
要是要体现局部和整体的关系的时候，而且这种关系还可能比较深，考虑一下组合模式吧。组合模式有一  
个非常明显的缺点，看到我们在 Client.java 中的的定义了树叶和树枝使用时的定义了吗？如下：

Branch developDep = new Branch(“刘大瘸子”,”研发部门经理”,10000);  
…  
Leaf g = new Leaf(“g”,”开发人员”,2000);

发现什么问题了吗？直接使用了实现类！这个在面向接口编程上是很不恰当的，这个在使用的时候要考虑清  
楚。  
组合模式在项目中到处都有，比如现在的页面结构一般都是上下结构，上面放系统的 Logo，下边分为  
两部分： 左边是导航菜单， 右边是展示区， 左边的导航菜单一般都是树形的结构， 比较清晰， 这个 JavaScript  
有很多例子，大家可以到网上搜索一把；还有，我们的自己也是一个树状结构，根据我，能够找到我的父  
母，根据父亲又能找到爷爷奶奶，根据母亲能够找到外公外婆等等，很典型的树形结构，而且还很规范（这  
个要是不规范那肯定是乱套了） 。  
我们在上面也还提到了一个问题，就是树的遍历问题，从上到下遍历没有问题，但是我要是从下往上  
遍历呢？比如在人力资源这颗树上，我从中抽取一个用户，要找到它的上级有哪些，下级有哪些，怎么处  
理？想想，~~~，再想想！想出来了吧，我们对下答案，先看类图：

![这里写图片描述][SouthEast 9]

看类图中的红色方框，只要增加两个方法就可以了，一个是设置父节点是谁，一个是查找父节点是谁，  
我们来看一下程序的改变：

package com.alex.patterns.composite;
    
    /** * @author Alex * 定义一个公司的人员的抽象类 */
    @SuppressWarnings("all")
    public abstract class Corp3 { 
        // 公司每个人都有名称
        private String name = "";
        // 公司每个人都职位
        private String position = "";
        // 公司每个人都有薪水
        private int salary = 0;
        //注意
        // 父节点是谁
        private Corp3 parent = null;
        //注意
    
        /* * 通过接口的方式传递，我们改变一下习惯，传递进来的参数名以下划线开始 这个在一些开源项目中非常常见，一般构造函数都是定义的 */
        public Corp3(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;
        }
    
        //注意
        // 设置父节点
        protected void setParent(Corp3 _parent) {
            this.parent = _parent;
        }
    
        // 得到父节点
        public Corp3 getParent() {
            return this.parent;
        }
        //注意
    }

就增加了注意部分，然后我们再来看看 Branch3.java 的改变：

package com.alex.patterns.composite;
    
    import java.util.ArrayList;
    
    /** * @author Alex * 节点类，也简单了很多 */
    public class Branch3 extends Corp3 { 
        // 领导下边有那些下级领导和小兵
        ArrayList<Corp3> subordinateList = new ArrayList<Corp3>();
    
        // 构造函数是必须的了
        public Branch3(String _name, String _position, int _salary) {
            super(_name, _position, _salary);
        }
    
        // 增加一个下属，可能是小头目，也可能是个小兵
        public void addSubordinate(Corp3 Corp3) {
            //注意
            Corp3.setParent(this); // 设置父节点
            //注意
            this.subordinateList.add(Corp3);
        }
    
        // 我有哪些下属
        public ArrayList<Corp3> getSubordinate() {
            return this.subordinateList;
        }
    }

增加了注意部分，看懂程序了吗？就是在每个节点甭管是树枝节点还是树叶节点，都增加了一个属性：  
父节点对象，这样在树枝节点增加子节点或叶子的时候设置父节点，然后你看整棵树就除了根节点外每个  
节点都一个父节点，剩下的事情还不好处理吗？每个节点上都有父节点了，你要往上找，那就找呗！Client  
程序我就不写了，今天已经拷贝的代码实在有点多，大家自己考虑一下，写个 find 方法，然后一个一个往  
上找，最简单的方法了！

[SouthEast]: /images/20220618/21cee90444684d0381e90bffb74e067d.png
[SouthEast 1]: /images/20220618/1b0011a41ba04b04b135e88bad05eb05.png
[SouthEast 2]: /images/20220618/905a4d53d41d4abe94ec9eda4a4d966f.png
[SouthEast 3]: /images/20220618/09bc4a9f7ba44a6db6d24e5c8a317ac1.png
[SouthEast 4]: /images/20220618/225470ba231c48e68d52fd26cb90df42.png
[SouthEast 5]: /images/20220618/4f148cb50da748d1af0536ae0ea4ef9b.png
[SouthEast 6]: /images/20220618/ea09497a49db4d99a10e6ff659cc56c8.png
[SouthEast 7]: /images/20220618/bf9aa40351bf420a851ca2f69cb208e6.png
[SouthEast 8]: /images/20220618/541baea55e444ac6aad4eccd51498632.png
[SouthEast 9]: /images/20220618/c8aa1d91db9a4e6184cb17296eb58e70.png