DesignPattern系列__06迪米特原则

  • 2019 年 10 月 3 日
  • 筆記

迪米特原则定义

迪米特原则,也叫最少知道原则,即一个类应该对自己依赖的类知道的越少越好,而你被依赖的类多么复杂,对我都没有关系。也就是说,对于别依赖的类来说,不管业务逻辑多么复杂,都应该尽量封装在类的内部;对外除了必备的public方法,不再泄露任何信息。

1.问题由来

我们知道,类和类是有耦合关系的,关系越密切的两个类之间,其耦合关系越大。

2.对应措施

迪米特原则要求:一个类应该只和之间的直接朋友通信。

1.直接朋友的定义

在上面我们提到了“直接朋友”这个概念,其实,在一个程序对象中,每个类都会和其他类有耦合关系,不然也就没有必要存在了。耦合的方式包括:依赖、关联、组合、聚合等。我们说,有耦合关系的两个类之间的关系,就是朋友关系。
那么,什么是“直接朋友”呢?
例如A类和B类具有耦合关系,若A类作为B类的成员变量、方法的形参、返回值,则说这两个类就是直接朋友;若A类作为B类的方法内的局部变量,则A类就不是B类的直接朋友。也就是说,陌生的类最好不要以局部变量的形式出现在类的内部。

3.应用实践

迪米特原则要求我们做到以下四点:

1.只和直接朋友沟通

为了说明这点,我们需要一个例子:比如在一所大学内有各个学院,现在要求打印出各个学院和学校总部的员工ID。代码演示如下:

 public class Demeter1 {      public static void main(String[] args) {          SchoolManager schoolManager = new SchoolManager();          schoolManager.printAllEmp(new CollegeManager());      }  }    class SchoolManager {      public void printAllEmp(CollegeManager collegeManager) {          List<Employee> empList = this.getAllEmployee();          System.out.println("打印学校总部的员工");          for (Employee employee: empList) {              employee.printId();          }           //分析问题      //1. 这里的 CollegeEmployee 不是  SchoolManager的直接朋友      //2. CollegeEmployee 是以局部变量方式出现在 SchoolManager          //3. 违反了 迪米特法则          List<CollegeEmployee> collegeEmpList = collegeManager.getAllEmployee();          System.out.println("打印学院员工");          for (CollegeEmployee collegeEmployee: collegeEmpList) {              collegeEmployee.printId();          }      }        //返回所用总部信息      public List<Employee> getAllEmployee() {          List<Employee> list = new ArrayList<>();          //添加5名总部的员工          for (int i=0; i<5;i++) {              Employee employee = new Employee();              employee.setId(i);              list.add(employee);          }          return list;      }  }    //学院员工的管理类  class CollegeManager {      //返回学院的所有员工      public List<CollegeEmployee> getAllEmployee() {          List<CollegeEmployee> list = new ArrayList<>();          //添加10名学院员工          for (int i = 0; i < 10; i++) {              CollegeEmployee emp = new CollegeEmployee();              emp.setId(i);              list.add(emp);          }          return list;      }  }    //学校员工类  class Employee {      private Integer id;        public Integer getId() {          return id;      }        public void setId(Integer id) {          this.id = id;      }        public void printId() {          System.out.println("学校员工,ID=" + this.getId());      }  }    //学院员工类  class CollegeEmployee {      private Integer id;        public Integer getId() {          return id;      }        public void setId(Integer id) {          this.id = id;      }        public void printId() {          System.out.println("学院员工,ID=" + this.getId());      }  }

根据上面的代码,我们来找一下类SchoolManager的直接朋友:Employee、CollegeManager,而CollegeEmployee 是以局部变量方式出现在 SchoolManager,这就违背了“迪米特原则”。

改进措施

既然如此,我们就要将CollegeEmployee从SchoolManager类中抽离出来,使其不被依赖。
在CollegeManager中增加一个打印学院员工的方法printCollegeEmps(),这样,SchoolManager就只需调用这个方法就行了。

  public void printCollegeEmps() {          List<CollegeEmployee> list = this.getAllEmployee();          for (CollegeEmployee collegeEmployee: list) {              collegeEmployee.printId();          }      }

2.和朋友也要保持适当距离

看到这里你可能会困惑,既然已经要求我们做到:一个类只和直接朋友沟通,那么为什么还要保持距离呢?还是举例说明:现在有两个类A、B,类A中有三个public方法,类B需要调用A中的三个方法来完成一个流程:

public class Demeter2 {      public static void main(String[] args) {          A a = new A();          B b = new B();          b.invokerA(a);      }  }    class A {      public void method1() {          System.out.println("执行第一个方法");      }        public void method2() {          System.out.println("执行第二个方法");      }        public void method3() {          System.out.println("执行第三个方法");      }    }    class B {      public void invokerA(A a) {          System.out.println("调用A的buildMethod()...");          a.method1();          a.method2();          a.method3();      }  }  

OK,功能完成了,但是,类B需要依次调用类A的三个方法,需要保持三个方法对类B都是可见的。也就是说,类B和类A的耦合度太高了,我们可以改善一下两者的关系,适度的降低一下耦合度。在类A中定义一个public方法,来封装类B的逻辑,其余方法设置为private。

 //类A的相应修改   private void method1() {          System.out.println("执行第一个方法");      }        private void method2() {          System.out.println("执行第二个方法");      }        private void method3() {          System.out.println("执行第三个方法");      }        public void buildMethod() {          System.out.println("流程开始");          method1();          method2();          method3();          System.out.println("流程结束");      }

3.是自己的就是自己的

当一个方法放在本类和其他类中都可以的时候,那么,如果,一个方法放在本类中,不会增加类之间的耦合度,也不会造成不良影响,放在本类中

4.慎用Serializable

举例来说,在一个项目中使用RMI方式传递一个VO对象时,这个对象就必须实现Serializable接口,也就是进行序列化。当你突然将客户端这个VO对象的访问权限从private更改为public的时候,而服务端没有进行对应的改变,就会出现错误。

4.迪米特原则的注意事项和细节

1.迪米特原则的核心就是降低类之间的耦合。只有耦合降低了,类的复用率才能提高。

2.注意事项:

凡事讲究适度,迪米特原则要求降低类之间的耦合,并不是要求没有耦合。