zoukankan      html  css  js  c++  java
  • 设计模式七大原则-迪米特法则

    基本介绍:

    一个对象应该对其他对象保持最少的了解

    类与类关系越密切,耦合度越大

    迪米特法则又叫最少知道原则,即一个类对自己依赖的类知道的越少越好。也就是说,对于被依赖的类不管多么复杂,都尽量将逻辑封装在类的内部,对外除了提供public方法,不对外泄露任何信息

    迪米特法则还有个更简单的定义:只与直接的朋友通信

    直接朋友

    每个对象都会与其他对象有耦合关系,只要两个对象之间有耦合关系,我们就说这两个对象之间是朋友关系,耦合的方式很多,依赖、联合、关联、组合、聚合等。

    其中我们称出现成员变量、方法参数、方法返回值中的类为直接朋友,而出现在局部变量中的类不是直接朋友,也就是说,陌生的类最好不要以局部变量的形式出现在类的内部。

    应用实例:

    有一个学校,下属有各个学院和总部,现要求打印出学校总部员工ID和学院员工的id

    package cn.rabcheng.demeterprinciple;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @auther cheng
     * @create 2020-08-15 17:38
     * 迪米特法则
     */
    public class DemeterPrinciple1 {
        public static void main(String[] args) {
            //创建了一个 SchoolManager 对象
            SchoolManager schoolManager = new SchoolManager();
            //输出学院的员工id 和  学校总部的员工信息
            schoolManager.printAllEmployee(new CollegeManager());
        }
    }
    
    
    //学校总部员工类
    class Employee {
        private String id;
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getId() {
            return id;
        }
    }
    
    
    //学院的员工类
    class CollegeEmployee {
        private String id;
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getId() {
            return id;
        }
    }
    
    
    //管理学院员工的管理类
    class CollegeManager {
        //返回学院的所有员工
        public List<CollegeEmployee> getAllEmployee() {
            List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
            for (int i = 0; i < 10; i++) { //这里我们增加了10个员工到 list
                CollegeEmployee emp = new CollegeEmployee();
                emp.setId("学院员工id= " + i);
                list.add(emp);
            }
            return list;
        }
    }
    
    //学校管理类
    
    //分析 SchoolManager 类的直接朋友类有哪些 Employee、CollegeManager
    //CollegeEmployee 不是 直接朋友 而是一个陌生类,这样违背了 迪米特法则
    class SchoolManager {
        //返回学校总部的员工
        public List<Employee> getAllEmployee() {
            List<Employee> list = new ArrayList<Employee>();
    
            for (int i = 0; i < 5; i++) { //这里我们增加了5个员工到 list
                Employee emp = new Employee();
                emp.setId("学校总部员工id= " + i);
                list.add(emp);
            }
            return list;
        }
    
        //该方法完成输出学校总部和学院员工信息(id)
        void printAllEmployee(CollegeManager sub) {
    
            //分析问题
            //1. 这里的 CollegeEmployee 不是  SchoolManager的直接朋友
            //2. CollegeEmployee 是以局部变量方式出现在 SchoolManager
            //3. 违反了 迪米特法则
    
            //获取到学院员工
            List<CollegeEmployee> list1 = sub.getAllEmployee();
            System.out.println("------------学院员工------------");
            for (CollegeEmployee e : list1) {
                System.out.println(e.getId());
            }
            //获取到学校总部员工
            List<Employee> list2 = this.getAllEmployee();
            System.out.println("------------学校总部员工------------");
            for (Employee e : list2) {
                System.out.println(e.getId());
            }
        }
    }

    分析:

    分析SchoolManager类的直接朋友类有哪些?Employee、CollageManager

    CollageEmployee不是直接朋友,而是一个局部变量,属于陌生类,违反了迪米特法则

    改进:

    package cn.rabcheng.demeterprinciple;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @auther cheng
     * @create 2020-08-15 17:48
     * 迪米特法则
     */
    public class DemeterPrinciple2 {
        public static void main(String[] args) {
    
            //创建了一个 SchoolManager 对象
            SchoolManager2 schoolManager = new SchoolManager2();
            //输出学院的员工id 和  学校总部的员工信息
            schoolManager.printAllEmployee(new CollegeManager2());
        }
    }
    
    
    //学校总部员工类
    class Employee2 {
        private String id;
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getId() {
            return id;
        }
    }
    
    
    //学院的员工类
    class CollegeEmployee2 {
        private String id;
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getId() {
            return id;
        }
    }
    
    
    //管理学院员工的管理类
    class CollegeManager2 {
        //返回学院的所有员工
        public List<CollegeEmployee2> getAllEmployee() {
            List<CollegeEmployee2> list = new ArrayList<CollegeEmployee2>();
            for (int i = 0; i < 10; i++) { //这里我们增加了10个员工到 list
                CollegeEmployee2 emp = new CollegeEmployee2();
                emp.setId("学院员工id= " + i);
                list.add(emp);
            }
            return list;
        }
    
        public void printAllEmployee() {
            //获取到学院员工
            List<CollegeEmployee2> list1 = getAllEmployee();
            System.out.println("------------学院员工------------");
            for (CollegeEmployee2 e : list1) {
                System.out.println(e.getId());
            }
        }
    }
    
    //学校管理类
    
    //分析 SchoolManager 类的直接朋友类有哪些 Employee、CollegeManager
    //CollegeEmployee 不是 直接朋友 而是一个陌生类,这样违背了 迪米特法则
    class SchoolManager2 {
        //返回学校总部的员工
        public List<Employee2> getAllEmployee() {
            List<Employee2> list = new ArrayList<Employee2>();
    
            for (int i = 0; i < 5; i++) { //这里我们增加了5个员工到 list
                Employee2 emp = new Employee2();
                emp.setId("学校总部员工id= " + i);
                list.add(emp);
            }
            return list;
        }
    
        //该方法完成输出学校总部和学院员工信息(id)
        void printAllEmployee(CollegeManager2 sub) {
    
            //分析问题
            //1. 这里的 CollegeEmployee 不是  SchoolManager的直接朋友
            //2. CollegeEmployee 是以局部变量方式出现在 SchoolManager
            //3. 违反了 迪米特法则
            sub.printAllEmployee();
    
            //获取到学校总部员工
            List<Employee2> list2 = this.getAllEmployee();
            System.out.println("------------学校总部员工------------");
            for (Employee2 e : list2) {
                System.out.println(e.getId());
            }
        }
    }

    迪米特法则注意事项和细节:

    迪米特法则的核心是降低类之间的耦合

    但是注意:由于每个类都减少了不必要的依赖,因此迪米特法则只是要求降低类间(对象间)耦合关系, 并不是要求完全没有依赖关系

  • 相关阅读:
    数学+高精度 ZOJ 2313 Chinese Girls' Amusement
    最短路(Bellman_Ford) POJ 1860 Currency Exchange
    贪心 Gym 100502E Opening Ceremony
    概率 Gym 100502D Dice Game
    判断 Gym 100502K Train Passengers
    BFS POJ 3278 Catch That Cow
    DFS POJ 2362 Square
    DFS ZOJ 1002/HDOJ 1045 Fire Net
    组合数学(全排列)+DFS CSU 1563 Lexicography
    stack UVA 442 Matrix Chain Multiplication
  • 原文地址:https://www.cnblogs.com/Rabcheng/p/13509709.html
Copyright © 2011-2022 走看看