设计模式之禅【组合模式】

爱被打了一巴掌 2022-06-02 10:51 183阅读 0赞

# 真刀实枪之组合模式 #

*  从公司的人事架构谈起吧
    
     *  公司的组织架构
        
         *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70][]
     *  从上图中可以分析出：
        
        1.  有分支的节点（树枝节点）
        2.  无分支的节点（叶子节点）
        3.  根节点（无父节点）
 *  有了树状结构图，再看看类图长啥样吧！
    
     *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 1][]
 *  这个类图是有缺陷的，等会儿继续修改，现在先看下这个不成熟类图的代码
    
     *  IRoot
        
            package com.peng.zh;
            
            import java.util.ArrayList;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月24日
             * @description
             */
            public interface IRoot {
                // 得到总经理想要的信息
                public String getInfo();
            
                // 添加树枝节点
                public void add(IBranch banch);
            
                // 添加叶子节点
                public void add(ILeaf leaf);
            
                // 遍历节点
                public ArrayList getSubordinateInfo();
            }
     *  Root
        
            package com.peng.zh;
            
            import java.util.ArrayList;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月24日
             * @description
             */
            public class Root implements IRoot {
                // 保存根节点下的树枝节点和叶子节点
                private ArrayList subordinateList = new ArrayList();
                // 根节点的名称
                private String name = "";
                // 根节点的职位
                private String position = "";
                // 根节点的薪水
                private int salary = 0;
            
                // 通过构造函数传递进来的总经理的信息
                Root(String name, String position, int salary) {
                    super();
                    this.name = name;
                    this.position = position;
                    this.salary = salary;
                }
            
                @Override
                public String getInfo() {
                    String info = "";
                    info += "根节点名称：" + this.name + "，根节点职位：" + this.position + "，根节点薪水："
                            + this.salary;
                    return info;
                }
            
                @Override
                public void add(IBranch branch) {
                    this.subordinateList.add(branch);
                }
            
                @Override
                public void add(ILeaf leaf) {
                    this.subordinateList.add(leaf);
                }
            
                @Override
                public ArrayList getSubordinateInfo() {
                    return this.subordinateList;
                }
            
            }
     *  IBranch
        
            package com.peng.zh;
            
            import java.util.ArrayList;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月24日
             * @description
             */
            public interface IBranch {
                // 得到信息
                public String getInfo();
            
                // 添加树枝节点
                public void add(IBranch banch);
            
                // 添加叶子节点
                public void add(ILeaf leaf);
            
                // 遍历节点
                public ArrayList getSubordinateInfo();
            }
     *  Branch
        
            package com.peng.zh;
            
            import java.util.ArrayList;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月24日
             * @description
             */
            public class Branch implements IBranch {
            
                // 保存树枝节点下的树枝节点和叶子节点
                private ArrayList subordinateList = new ArrayList();
                // 树枝节点的名称
                private String name = "";
                // 树枝节点的职位
                private String position = "";
                // 树枝节点的薪水
                private int salary = 0;
            
                // 通过构造函数传递进来的树枝节点的信息
                Branch(String name, String position, int salary) {
                    super();
                    this.name = name;
                    this.position = position;
                    this.salary = salary;
                }
            
                @Override
                public String getInfo() {
                    String info = "";
                    info += "树枝节点名称：" + this.name + "，树枝节点职位：" + this.position + "，树枝节点薪水："
                            + this.salary;
                    return info;
                }
            
                @Override
                public void add(IBranch branch) {
                    this.subordinateList.add(branch);
                }
            
                @Override
                public void add(ILeaf leaf) {
                    this.subordinateList.add(leaf);
                }
            
                @Override
                public ArrayList getSubordinateInfo() {
                    return this.subordinateList;
                }
            
            }
     *  ILeaf
        
            package com.peng.zh;
            
            import java.util.ArrayList;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月24日
             * @description
             */
            public interface ILeaf {
                // 得到信息
                public String getInfo();
            
            }
     *  Leaf
        
            package com.peng.zh;
            
            import java.util.ArrayList;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月24日
             * @description
             */
            public class Leaf implements ILeaf {
                // 叶子节点的名称
                private String name = "";
                // 叶子节点的职位
                private String position = "";
                // 叶子节点的薪水
                private int salary = 0;
            
                // 通过构造函数传递进来的叶子节点的信息
                Leaf(String name, String position, int salary) {
                    super();
                    this.name = name;
                    this.position = position;
                    this.salary = salary;
                }
            
                @Override
                public String getInfo() {
                    String info = "";
                    info += "叶子节点名称：" + this.name + "，叶子节点职位：" + this.position + "，叶子节点薪水："
                            + this.salary;
                    return info;
                }
            
            }
     *  Client
        
            package com.peng.zh;
            
            import java.util.ArrayList;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月24日
             * @description
             */
            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 firstDepGroup = new Branch("杨三也斜", "开发一组组长", 5000);
                    IBranch secondDepGrooup = new Branch("吴大棒槌", "开发二组组长", 6000);
                    // 研发部经理
                    ILeaf zhengLaoLiu = new Leaf("郑老六", "研发部副总", 20000);
                    // 员工
                    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);
                    // 组装总经理
                    ceo.add(developDep);
                    ceo.add(salesDep);
                    ceo.add(financeDep);
                    ceo.add(k);
                    // 组装研发部门
                    developDep.add(firstDepGroup);
                    developDep.add(secondDepGrooup);
                    developDep.add(zhengLaoLiu);
                    // 组装第一个开发小组
                    firstDepGroup.add(a);
                    firstDepGroup.add(c);
                    firstDepGroup.add(d);
                    // 组装第二个开发小组
                    secondDepGrooup.add(e);
                    secondDepGrooup.add(f);
                    secondDepGrooup.add(g);
                    // 组装销售部
                    salesDep.add(h);
                    salesDep.add(i);
                    // 组装财务部
                    financeDep.add(j);
                    // 打印出来整个树形结构
                    System.out.println(ceo.getInfo());
                    getAllSubordinateInfo(ceo.getSubordinateInfo());
            
                }
            
                private static void getAllSubordinateInfo(ArrayList subordinateInfo) {
                    int length = subordinateInfo.size();
                    for (int i = 0; i < length; i++) {
                        Object s = subordinateInfo.get(i);
                        if (s instanceof Leaf) {
                            ILeaf employee = (ILeaf) s;
                            System.out.println(employee.getInfo());
                        } else {
                            IBranch branch = (IBranch) s;
                            System.out.println(branch.getInfo());
                            // 递归
                            getAllSubordinateInfo(branch.getSubordinateInfo());
                        }
                    }
                }
            
            }
     *  执行结果
        
            根节点名称：王大麻子，根节点职位：总经理，根节点薪水：100000
            树枝节点名称：刘大瘸子，树枝节点职位：研发部门经理，树枝节点薪水：10000
            树枝节点名称：杨三也斜，树枝节点职位：开发一组组长，树枝节点薪水：5000
            叶子节点名称：a，叶子节点职位：开发人员，叶子节点薪水：2000
            叶子节点名称：c，叶子节点职位：开发人员，叶子节点薪水：2000
            叶子节点名称：d，叶子节点职位：开发人员，叶子节点薪水：2000
            树枝节点名称：吴大棒槌，树枝节点职位：开发二组组长，树枝节点薪水：6000
            叶子节点名称：e，叶子节点职位：开发人员，叶子节点薪水：2000
            叶子节点名称：f，叶子节点职位：开发人员，叶子节点薪水：2000
            叶子节点名称：g，叶子节点职位：开发人员，叶子节点薪水：2000
            叶子节点名称：郑老六，叶子节点职位：研发部副总，叶子节点薪水：20000
            树枝节点名称：马二拐子，树枝节点职位：销售部门经理，树枝节点薪水：20000
            叶子节点名称：h，叶子节点职位：销售人员，叶子节点薪水：5000
            叶子节点名称：i，叶子节点职位：销售人员，叶子节点薪水：4000
            树枝节点名称：赵三驼子，树枝节点职位：财务部门经理，树枝节点薪水：30000
            叶子节点名称：j，叶子节点职位：财务人员，叶子节点薪水：5000
            叶子节点名称：k，叶子节点职位：ceo秘书人员，叶子节点薪水：8000
 *  好，代码写完，把刚刚遗留的问题来找一下：
    
    1.  getInfo每个接口都有，为什么不抽象出来？
    2.  Root和Branch类有什么差别？
    3.  根节点本来就是树枝节点的一种，为什么要定义成两个接口？
    4.  若果我要增加一个任职期限，是不是所有的都要修改？
    5.  如果我要后续遍历，能做到吗？
 *  问题很多，一个一个解决
    
    1.  先说抽象问题，确实可以抽象出来，修改下类图
        
        1.  修改
            
            1.  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 2][]
        2.  仔细看这个图，能不能发现还有问题--想想接口的作用是什么？定义共性，既然是这样，那getInfo方法也可以封装啦，再继续修改
        3.  修改2
            
            1.  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 3][]
        4.  类图上增加了一个ICorp接口，它是公司所有员工的接口类
        5.  新类图的代码
            
            1.  ICorp
                
                    package zh2;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月24日
                     * @description
                     */
                    public interface ICorp {
                        // 获取信息
                        public String getInfo();
                    }
            2.  ILeaf
                
                    package zh2;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月24日
                     * @description
                     */
                    public interface ILeaf extends ICorp {
                    
                    }
            3.  Leaf
                
                    package zh2;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月24日
                     * @description
                     */
                    public class Leaf implements ILeaf {
                    
                        // 叶子节点的名称
                        private String name = "";
                        // 叶子节点的职位
                        private String position = "";
                        // 叶子节点的薪水
                        private int salary = 0;
                    
                        // 通过构造函数传递进来的叶子节点的信息
                        Leaf(String name, String position, int salary) {
                            super();
                            this.name = name;
                            this.position = position;
                            this.salary = salary;
                        }
                    
                        @Override
                        public String getInfo() {
                            String info = "";
                            info += "叶子节点名称：" + this.name + "，叶子节点职位：" + this.position + "，叶子节点薪水："
                                    + this.salary;
                            return info;
                        }
                    
                    }
            4.  IBranch
                
                    package zh2;
                    
                    import java.util.ArrayList;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月24日
                     * @description
                     */
                    public interface IBranch extends ICorp {
                        // 增高增加小兵
                        public void addSubordinate(ICorp corp);
                    
                        // 获得下属信息
                        public ArrayList<ICorp> getSubordinate();
                        // 删除下属--没用到，这里省略
                    }
            5.  Branch
                
                    package zh2;
                    
                    import java.util.ArrayList;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月24日
                     * @description
                     */
                    public class Branch implements IBranch {
                        // 保存节点下的树枝节点和叶子节点
                        private ArrayList<ICorp> subordinateList = new ArrayList<ICorp>();
                        // 树枝节点的名称
                        private String name = "";
                        // 树枝节点的职位
                        private String position = "";
                        // 树枝节点的薪水
                        private int salary = 0;
                    
                        // 通过构造函数传递进来的树枝节点的信息
                        Branch(String name, String position, int salary) {
                            super();
                            this.name = name;
                            this.position = position;
                            this.salary = salary;
                        }
                    
                        @Override
                        public String getInfo() {
                            String info = "";
                            info += "树枝节点名称：" + this.name + "，树枝节点职位：" + this.position + "，树枝节点薪水："
                                    + this.salary;
                            return info;
                        }
                    
                        @Override
                        public void addSubordinate(ICorp corp) {
                            this.subordinateList.add(corp);
                        }
                    
                        @Override
                        public ArrayList<ICorp> getSubordinate() {
                            return this.subordinateList;
                        }
                    
                    }
            6.  Client
                
                    package zh2;
                    
                    import java.util.ArrayList;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月24日
                     * @description
                     */
                    public class Client {
                        public static void main(String[] args) {
                    
                            // 先产生根节点
                            Branch ceo = new Branch("王大麻子", "总经理", 100000);
                            // 产生三个部门经理
                            IBranch developDep = new Branch("刘大瘸子", "研发部门经理", 10000);
                            IBranch salesDep = new Branch("马二拐子", "销售部门经理", 20000);
                            IBranch financeDep = new Branch("赵三驼子", "财务部门经理", 30000);
                            // 两个小组长
                            IBranch firstDepGroup = new Branch("杨三也斜", "开发一组组长", 5000);
                            IBranch secondDepGrooup = new Branch("吴大棒槌", "开发二组组长", 6000);
                            // 研发部经理
                            ILeaf zhengLaoLiu = new Leaf("郑老六", "研发部副总", 20000);
                            // 员工
                            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);
                            // 组装总经理
                            ceo.addSubordinate(developDep);
                            ceo.addSubordinate(salesDep);
                            ceo.addSubordinate(financeDep);
                            ceo.addSubordinate(k);
                            // 组装研发部门
                            developDep.addSubordinate(firstDepGroup);
                            developDep.addSubordinate(secondDepGrooup);
                            developDep.addSubordinate(zhengLaoLiu);
                            // 组装第一个开发小组
                            firstDepGroup.addSubordinate(a);
                            firstDepGroup.addSubordinate(c);
                            firstDepGroup.addSubordinate(d);
                            // 组装第二个开发小组
                            secondDepGrooup.addSubordinate(e);
                            secondDepGrooup.addSubordinate(f);
                            secondDepGrooup.addSubordinate(g);
                            // 组装销售部
                            salesDep.addSubordinate(h);
                            salesDep.addSubordinate(i);
                            // 组装财务部
                            financeDep.addSubordinate(j);
                            // 打印出来整个树形结构
                            System.out.println(ceo.getInfo());
                            getAllSubordinateInfo(ceo.getSubordinate());
                    
                        }
                    
                        private static void getAllSubordinateInfo(ArrayList subordinateInfo) {
                            int length = subordinateInfo.size();
                            for (int i = 0; i < length; i++) {
                                Object s = subordinateInfo.get(i);
                                if (s instanceof Leaf) {
                                    ILeaf employee = (ILeaf) s;
                                    System.out.println(employee.getInfo());
                                } else {
                                    IBranch branch = (IBranch) s;
                                    System.out.println(branch.getInfo());
                                    // 递归
                                    getAllSubordinateInfo(branch.getSubordinate());
                                }
                            }
                        }
                    }
            7.  执行结果
                
                    树枝节点名称：王大麻子，树枝节点职位：总经理，树枝节点薪水：100000
                    树枝节点名称：刘大瘸子，树枝节点职位：研发部门经理，树枝节点薪水：10000
                    树枝节点名称：杨三也斜，树枝节点职位：开发一组组长，树枝节点薪水：5000
                    叶子节点名称：a，叶子节点职位：开发人员，叶子节点薪水：2000
                    叶子节点名称：c，叶子节点职位：开发人员，叶子节点薪水：2000
                    叶子节点名称：d，叶子节点职位：开发人员，叶子节点薪水：2000
                    树枝节点名称：吴大棒槌，树枝节点职位：开发二组组长，树枝节点薪水：6000
                    叶子节点名称：e，叶子节点职位：开发人员，叶子节点薪水：2000
                    叶子节点名称：f，叶子节点职位：开发人员，叶子节点薪水：2000
                    叶子节点名称：g，叶子节点职位：开发人员，叶子节点薪水：2000
                    叶子节点名称：郑老六，叶子节点职位：研发部副总，叶子节点薪水：20000
                    树枝节点名称：马二拐子，树枝节点职位：销售部门经理，树枝节点薪水：20000
                    叶子节点名称：h，叶子节点职位：销售人员，叶子节点薪水：5000
                    叶子节点名称：i，叶子节点职位：销售人员，叶子节点薪水：4000
                    树枝节点名称：赵三驼子，树枝节点职位：财务部门经理，树枝节点薪水：30000
                    叶子节点名称：j，叶子节点职位：财务人员，叶子节点薪水：5000
                    叶子节点名称：k，叶子节点职位：ceo秘书人员，叶子节点薪水：8000
        6.  getInfo方法都有，是不是可以继续优化，把ICorp接口变化成一个抽象类，将getInfo方法在抽象类中实现
            
            1.  再次修改类图
                
                1.  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 4][]
            2.  代码实现
                
                1.  Corp
                    
                        package zh3;
                        
                        
                        /**
                         * @author kungfu~peng
                         * @data 2017年11月25日
                         * @description
                         */
                        public abstract class Corp {
                            // 树枝节点的名称
                            private String name = "";
                            // 树枝节点的职位
                            private String position = "";
                            // 树枝节点的薪水
                            private int salary = 0;
                        
                            // 通过构造函数传递进来的树枝节点的信息
                            Corp(String name, String position, int salary) {
                                this.name = name;
                                this.position = position;
                                this.salary = salary;
                            }
                        
                            public String getInfo() {
                                String info = "";
                                info += "树枝节点名称：" + this.name + "，树枝节点职位：" + this.position + "，树枝节点薪水："
                                        + this.salary;
                                return info;
                            }
                        
                        }
                2.  Branch
                    
                        package zh3;
                        
                        import java.util.ArrayList;
                        
                        import zh2.ICorp;
                        
                        /**
                         * @author kungfu~peng
                         * @data 2017年11月25日
                         * @description
                         */
                        public class Branch extends Corp {
                            // 保存节点下的树枝节点和叶子节点
                            private ArrayList<Corp> subordinateList = new ArrayList<Corp>();
                        
                            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;
                            }
                        }
                3.  Leaf
                    
                        package zh3;
                        
                        /**
                         * @author kungfu~peng
                         * @data 2017年11月25日
                         * @description
                         */
                        public class Leaf extends Corp {
                        
                            Leaf(String name, String position, int salary) {
                                super(name, position, salary);
                            }
                        
                        }
                4.  Client
                    
                        package zh3;
                        
                        import java.util.ArrayList;
                        
                        /**
                         * @author kungfu~peng
                         * @data 2017年11月25日
                         * @description
                         */
                        public class Client {
                        
                            public static void main(String[] args) {
                        
                                // 先产生根节点
                                Branch ceo = new Branch("王大麻子", "总经理", 100000);
                                // 产生三个部门经理
                                Branch developDep = new Branch("刘大瘸子", "研发部门经理", 10000);
                                Branch salesDep = new Branch("马二拐子", "销售部门经理", 20000);
                                Branch financeDep = new Branch("赵三驼子", "财务部门经理", 30000);
                                // 两个小组长
                                Branch firstDepGroup = new Branch("杨三也斜", "开发一组组长", 5000);
                                Branch secondDepGrooup = new Branch("吴大棒槌", "开发二组组长", 6000);
                                // 研发部经理
                                Leaf zhengLaoLiu = new Leaf("郑老六", "研发部副总", 20000);
                                // 员工
                                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);
                                // 组装总经理
                                ceo.addSubordinate(developDep);
                                ceo.addSubordinate(salesDep);
                                ceo.addSubordinate(financeDep);
                                ceo.addSubordinate(k);
                                // 组装研发部门
                                developDep.addSubordinate(firstDepGroup);
                                developDep.addSubordinate(secondDepGrooup);
                                developDep.addSubordinate(zhengLaoLiu);
                                // 组装第一个开发小组
                                firstDepGroup.addSubordinate(a);
                                firstDepGroup.addSubordinate(c);
                                firstDepGroup.addSubordinate(d);
                                // 组装第二个开发小组
                                secondDepGrooup.addSubordinate(e);
                                secondDepGrooup.addSubordinate(f);
                                secondDepGrooup.addSubordinate(g);
                                // 组装销售部
                                salesDep.addSubordinate(h);
                                salesDep.addSubordinate(i);
                                // 组装财务部
                                financeDep.addSubordinate(j);
                                // 打印出来整个树形结构
                                System.out.println(ceo.getInfo());
                                getAllSubordinateInfo(ceo.getSubordinate());
                        
                            }
                        
                            private static void getAllSubordinateInfo(ArrayList subordinateInfo) {
                                int length = subordinateInfo.size();
                                for (int i = 0; i < length; i++) {
                                    Object s = subordinateInfo.get(i);
                                    if (s instanceof Leaf) {
                                        Leaf employee = (Leaf) s;
                                        System.out.println(employee.getInfo());
                                    } else {
                                        Branch branch = (Branch) s;
                                        System.out.println(branch.getInfo());
                                        // 递归
                                        getAllSubordinateInfo(branch.getSubordinate());
                                    }
                                }
                            }
                        }
                5.  执行结果
                    
                        树枝节点名称：王大麻子，树枝节点职位：总经理，树枝节点薪水：100000
                        树枝节点名称：刘大瘸子，树枝节点职位：研发部门经理，树枝节点薪水：10000
                        树枝节点名称：杨三也斜，树枝节点职位：开发一组组长，树枝节点薪水：5000
                        树枝节点名称：a，树枝节点职位：开发人员，树枝节点薪水：2000
                        树枝节点名称：c，树枝节点职位：开发人员，树枝节点薪水：2000
                        树枝节点名称：d，树枝节点职位：开发人员，树枝节点薪水：2000
                        树枝节点名称：吴大棒槌，树枝节点职位：开发二组组长，树枝节点薪水：6000
                        树枝节点名称：e，树枝节点职位：开发人员，树枝节点薪水：2000
                        树枝节点名称：f，树枝节点职位：开发人员，树枝节点薪水：2000
                        树枝节点名称：g，树枝节点职位：开发人员，树枝节点薪水：2000
                        树枝节点名称：郑老六，树枝节点职位：研发部副总，树枝节点薪水：20000
                        树枝节点名称：马二拐子，树枝节点职位：销售部门经理，树枝节点薪水：20000
                        树枝节点名称：h，树枝节点职位：销售人员，树枝节点薪水：5000
                        树枝节点名称：i，树枝节点职位：销售人员，树枝节点薪水：4000
                        树枝节点名称：赵三驼子，树枝节点职位：财务部门经理，树枝节点薪水：30000
                        树枝节点名称：j，树枝节点职位：财务人员，树枝节点薪水：5000
                        树枝节点名称：k，树枝节点职位：ceo秘书人员，树枝节点薪水：8000

### 组合模式的定义 ###

*  Composite Pattern
 *  也叫合成模式或整体-部分模式，主要是描述部分与整体的关系
 *  Compose objects into tree structures to represent part-whole hirearchies.Composite lets clients treat individual objects and compositions of objects uniformly.(将对象组合成树形结构，以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性)

### 通用类图 ###

*  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 5][]
 *  几个角色
    
    1.  Component抽象构建角色：可以定义属性和方法
    2.  Leaf叶子构件：遍历的最小单位
    3.  Composite树枝构件：中间节点或根节点
 *  通用代码这里不再赘述

### 组合模式的应用 ###

*  组合模式的优点
    
    1.  高层模块调用简单
    2.  节点自由增加
 *  组合模式的缺点
    
    1.  场景类直接使用了树叶节点和树枝节点，这在面向接口编程上是很不恰当的，与依赖原则冲突
 *  使用场景
    
    1.  维护和展示“部分-整体”关系的场景--树形菜单、文件和文件夹管理
    2.  从一个整体中能够独立出部分模块或功能的场景

### 组合模式的注意事项 ###

*  只要是树形结构就考虑组合模式--体现“部分-整体”关系的时候

### 组合模式的扩展 ###

*  安全模式的组合模式【之前写的就是】
 *  透明的组合模式
    
     *  类图
        
         *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 6][]
         *  透明模式就是将组合使用的方法放到抽象类中，不管是叶子还是树枝都有这个方法，通过判断getChild的返回值确定是叶子节点还是树枝节点，如果处理不当，运行期间会出问题
         *  不是很建议这种方式
         *  代码--注意叶子节点的add方法的重写--抛出“不支持请求异常”即可--throw new UnsupportedOperationException();
 *  组合模式的遍历
    
    1.  上到下【上面的已经实现】
    2.  下到上【增加parent】
        
        1.  类图
            
            1.  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 7][]
        2.  代码（看了这么多，自己动手试一试）

### 最佳实践 ###

*  页面结构【top，center（left，right），bottom】
 *  JavaScript
 *  xml
 *  血缘关系

### 声明 ###

*  摘自秦小波《设计模式之禅》第2版；
 *  仅供学习，严禁商业用途；
 *  代码手写，没有经编译器编译，有个别错误，自行根据上下文改正；

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70]: /images/20220602/442a88adef5c45559caab4aff29c1a9b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 1]: /images/20220602/c2deb591219e4cf99f50c5e5fd8f78b8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 2]: /images/20220602/fd4b16ba464d4f78a0cb7955e236c5ce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 3]: /images/20220602/b06e39a4ee4845a9a982ad2d79afde58.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 4]: /images/20220602/b2efc9c397dd4dd3804d8b4d06988ca6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 5]: /images/20220602/2fb8649d02024ca3971a46e1ae5c06e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 6]: /images/20220602/907e2016ad1b4a1aa4047f4325e07a6e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 7]: /images/20220602/b2c6cc2e1dc64e7b984a916f98604190.png