设计模式之组合模式(15):对层级数据递归调用执行操做

场景

场景：
（1）父部门->子部门->子部门
（2）咱们要对部门树，删除一个父部门以及其下全部的子部门

内容

1.不使用设计模式

部门树形结构,咱们能够用一个对象来表示,里面报表集合属性。

1.1 类图

1. 组装部门树时候,只须要一级一级的组装
2. 删除时候根据遍历删除

1.2 代码

public class NonPattern2 {
    public static void main(String[] args) {
        //1.根节点
        Department rootDepartment = new Department("根部门");

        //2.子节点
        Department subDepartment1 = new Department("子部门1");
        Department subDepartment2 = new Department("子部门2");

        //3.孙子节点
        Department leafDepartment1 = new Department("叶子部门1");
        Department leafDepartment2 = new Department("叶子部门2");
        Department leafDepartment3 = new Department("叶子部门3");

        //4.组装数据
         rootDepartment.getChidlren().add(subDepartment1);
         rootDepartment.getChidlren().add(subDepartment2);

         subDepartment1.getChidlren().add(leafDepartment1);
         subDepartment1.getChidlren().add(leafDepartment2);
         subDepartment2.getChidlren().add(leafDepartment3);


         //5.删除数据
         for (Department subDept:rootDepartment.getChidlren()){
             if(subDept.getChidlren().size()>0){
                 for (Department leafDept:subDept.getChidlren()){
                     leafDept.remove();
                 }
             }
             subDept.remove();
         }
         rootDepartment.remove();

        /**
         * 输出:
         * 删除部门【叶子部门1】
         * 删除部门【叶子部门2】
         * 删除部门【子部门1】
         * 删除部门【叶子部门3】
         * 删除部门【子部门2】
         * 删除部门【根部门】
         */
    }

    public static class Department{
        private String name;
        private List<Department> chidlren = new ArrayList();

        public Department(String name){
            this.name = name;
        }
        public void remove(){
                System.out.println("删除部门【" + name + "】");
        }
        public void setChidlren(List<Department> chidlren) {
            this.chidlren = chidlren;
        }

        public List<Department> getChidlren() {
            return chidlren;
        }

        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }
}

2.使用组合模式

2.1 类图

1. 组合设计模式和不使用设计模式的类图相似,最主要区别是remove方法执行逻辑。
2. remove方法实现递归删除。

2.2 代码

public class CompositePattern2 {

    public static void main(String[] args) {
        //1.父部门
        Department parentDept = new Department("父部门");

        //2.子部门
        Department subDept1 = new Department("子部门1");
        Department subDept2 = new Department("子部门2");

        //3.叶子部门
        Department leafDept1 = new Department("叶子部门1");
        Department leafDept2 = new Department("叶子部门2");
        Department leafDept3 = new Department("叶子部门3");

        //4.组装数据
        subDept1.getChildren().add(leafDept1);
        subDept1.getChildren().add(leafDept2);
        subDept2.getChildren().add(leafDept3);

        parentDept.getChildren().add(subDept1);
        parentDept.getChildren().add(subDept2);

        //5.删除
        parentDept.remove();
    }


    public static class Department{
        private String name;
        private List<Department> children = new ArrayList<Department>();

        public Department(String name){
            super();
            this.name = name;
        }
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public List<Department> getChildren() {
            return children;
        }

        public void setChildren(List<Department> children) {
            this.children = children;
        }

        //===================关键点=================
        public void remove(){
            //递归删除:递归找准结束边界:对象的属性集合不大于0就结束
            if(children.size()>0){
              for (Department child:children){
                  child.remove();//递归调用
              }
            }
            System.out.println("删除部门【" + name + "】");
        }
    }
}

3.总结

3.1 不使用设计模式

1. 调用方须要知道被调用方逻辑,而且须要使用大量if---for,若是被调用方更改了里面逻辑代码,那么调用方也得更改里面代码。

3.2 使用设计模式

1. 组合模式的第一要义，就是将树形结构的数据，用一个类，或者少数一两个类，就能够拼装成一棵树的形状。
2. 组合模式的第二要义，就是直接对一个父级的数据执行某个操做，这个操做会直接递归调用全部下层的子数据的相关操做;经过这个树形结构本身递归本身的方式，就将对一棵树的操做，完美的执行了
3. 好处，就是对树形数据的操做，不须要调用方组织复杂的屎同样的if for的代码，去执行。
4. 外部要操做一颗树，直接对树的父级节点，调用一个操做，这颗树本身就递归着把事儿给干完了。
5. 设计模式，重点，是思想，理解了思想，随便招式你怎么出，只要能将思想运用到实际业务场景中；避免写出垃圾代码，你就成功了；若是你照搬设计模式去写，反而增长代码的复杂度。