迪米特法则

痛定思痛。 2022-09-19 00:17 127阅读 0赞

迪米特法则（Law of Demeter,LoD）也称为最少知识原则（Least KnowLedge Principle, LKP），虽然名字不同，但描述的是同一个规则：一个对象应该对其他对象有最少的了解。通俗地讲，一个类应该对自己需要耦合或者调用的类知道得最少，你（被耦合或调用的类）的内部是如何复杂都和我没关系，那是你的事情，我就知道你提供了这么多的public方法，我就调用这么多，其他的我一概不关心。

迪米特法则对类的低耦合提供了明确的要求，其包含以下四层含义：

#### 1、只和朋友交流 ####

迪米特法则还有一个英文解释：Only talk to your immedate friends（只与直接的朋友通信）。什么叫直接的朋友呢？每个对象都必然会与其他对象有耦合关系，两个对象直接的耦合就成为朋友关系，这种关系的类型有很多，例如组合、聚合、依赖等。下面举例介绍说明如何才能做到只与直接的朋友交流。

例如，老是想让体育委员确认以下女生人数，我们来看怎么用程序来实现，类图如图：

[![image][]][image 1]Teacher类的commond方法负责发送命令给体育委员，命令他清点女生，其实现过程如下：

[![image][image 2]][image_image 2]

老师只有一个commond方法，先定义出所有的女生，然后发命令给体育委员，去清点以下女生的数量。体育委员GroupLeader的实现过程如下：

[![image][image 3]][image_image 3]老师类和体育委员类都对女生类产生了依赖，而且女生类不需要执行任何动作，因此定义一个空类，如图：

[![image][image 4]][image_image 4]

故事中的三个角色都有了，在定义一个场景来描述这个故事，实现过程如下：

[![image][image 5]][image_image 5]运行结果：

[![image][image 6]][image_image 6]体育委员按照老师的要求对女生进行了清点，并得出了数量。我们回过头来思考一下这个程序有什么问题，首先确定Teacher有几个朋友类，他仅有一个朋友类：GroupLeader。为什么Girl不是朋友类呢？Teacher也对他产生了依赖关系啊！朋友类的定义是这样的：出现在成员变量，方法的输入输出中的类称为成员朋友类。迪米特法则告诉我们一个类只和朋友类交流，但是我们刚刚定义的commond方法却与Girl类有了交流，声明了一个List动态数组，也就是与一个陌生的类Girl有了交流，这样就破坏了Teacher的健壮性。方法是类的一个行为，类竟然不知道与其他类产生了依赖关系，这是不允许的，严重违反了迪米特法则。

可以这样子修改，在类图中去掉Teacher对Girl类的依赖关系，修改后的Teacher类如下：

[![image][image 7]][image_image 7]

修改后的体育委员类:

[![image][image 8]][image_image 8]修改后的场景类：

[![image][image 9]][image_image 9]把Teacher中对List的初始化移动到了场景类中，同时在GroupLeader中增加了对Girl的注入，避开了Teacher类对陌生类Girl的访问，降低了系统间的耦合，提高了系统的健壮性。

注意：一个类只和朋友交流，不与陌生类交流，类与类之间的关系是建立在类间的，而不是方法间，因此一个方法尽量不引入一个类中不存在的对象，当然JDK API提供的类除外。

#### 2、朋友间也是有距离的 ####

朋友间是有距离的，太远关系逐渐疏远，最终形成陌路；太近就互相刺伤，必须保持一个合适的距离。迪米特法则就是对这个距离的描述，即使是朋友类之间也不能无话不说，无所不知。

例如，我们在安装软时，经常有一个导向动作，第一步是确认是否安装，第二步是确认License，然后再选择安装目录；这是一个典型的顺序执行动作，具体到程序中就是：调用一个或者多个类，先执行第一个方法，然后是第二个方法，根据返回结果再来看是否调用第三个方法，其类图如下：

[![image][image 10]][image_image 10]

很简单的类图，实现软件安装的过程，其中first方法定义第一步做什么，second方法定义第二步做什么，其实现过程如下：

[![image][image 11]][image_image 11]InstallSoftware类：

[![image][image 12]][image_image 12]程序虽然简单，隐藏的问题可不简单，思考一下程序有什么问题。Wizard类把太多的方法暴露给InstallSoftware类，两者的朋友关系太紧密了，耦合关系变得异常牢固。如果要将Wizard类中的first方法返回值的类型由int改为boolean，就需要修改InstallSoftware类，从而把修改变更的风险扩散开来。因此这样的耦合是极度不合适的，我们需要重新对设计进行重构，重构后的类图如下：

[![image][image 13]][image_image 13] 在Wizard类方法中增加一个installWizard方法，对安装过程进行封装，同时把原有的三个public方法修改为private方法，如下所示：

[![image][image 14]][image_image 14]

修改后的InstallSoftware类：

[![image][image 15]][image_image 15]通过这样的重构后，Wizard类对外只公布了一个public方法，即使要修改first的返回值，影响的也只是Wizard本身，其他类不受影响，这显示了类的高内聚特性。

注意：迪米特法则要求类“羞涩”一点，尽量不要对外公布太多的public方法和非静态的public变量，尽量内敛，多使用private、protected等访问权限。

#### 3、是自己的就是自己的 ####

在实际应用中经常出现这样一个方法，放在本类中也可以，放在其他类中也没错，那怎么去衡量呢？你可以坚持这样一个原则：如果一个方法放在本类中，即不增加类间关系，也不对本类产生负面影响，就放置在本类中。

总结：迪米特法则的核心观念就是类间解耦，弱耦合，只有弱耦合了以后，类的复用率才能提高。其要求的结果就是产生了大量的中转或跳转类，导致系统的复杂性提高，同时也为维护带来了难度。

定义：一个对象应该对其他对象保持最少的了解。

**问题由来：**类与类之间的关系越密切，耦合度越大，当一个类发生改变时，对另一个类的影响也越大。

**解决方案：**尽量降低类与类之间的耦合。

自从我们接触编程开始，就知道了软件编程的总的原则：低耦合，高内聚。无论是面向过程编程还是面向对象编程，只有使各个模块之间的耦合尽量的低，才能提高代码的复用率。低耦合的优点不言而喻，但是怎么样编程才能做到低耦合呢？那正是迪米特法则要去完成的。

迪米特法则又叫最少知道原则，最早是在1987年由美国Northeastern University的Ian Holland提出。通俗的来讲，就是一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类来说，无论逻辑多么复杂，都尽量地的将逻辑封装在类的内部，对外除了提供的public方法，不对外泄漏任何信息。迪米特法则还有一个更简单的定义：**只与直接的朋友通信。**首先来解释一下什么是直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖、关联、组合、聚合等。其中，我们称出现成员变量、方法参数、方法返回值中的类为**直接的朋友**，而出现在局部变量中的类则不是直接的朋友。也就是说，陌生的类最好不要作为局部变量的形式出现在类的内部。

举一个例子：有一个集团公司，下属单位有分公司和直属部门，现在要求打印出所有下属单位的员工ID。先来看一下违反迪米特法则的设计。

**\[java\]** [view plain][] [copy][view plain]

1.  //总公司员工
2.  **class** Employee\{ 
3.  **private** String id; 
4.  **public****void** setId(String id)\{ 
5.  **this**.id = id; 
6.   \} 
7.  **public** String getId()\{ 
8.  **return** id; 
9.   \} 
10. \} 
11. 
12. //分公司员工
13. **class** SubEmployee\{ 
14. **private** String id; 
15. **public****void** setId(String id)\{ 
16. **this**.id = id; 
17.  \} 
18. **public** String getId()\{ 
19. **return** id; 
20.  \} 
21. \} 
22. 
23. **class** SubCompanyManager\{ 
24. **public** List<SubEmployee> getAllEmployee()\{ 
25.  List<SubEmployee> list = **new** ArrayList<SubEmployee>(); 
26. **for**(**int** i=0; i<100; i++)\{ 
27.  SubEmployee emp = **new** SubEmployee(); 
28. //为分公司人员按顺序分配一个ID
29.  emp.setId("分公司"\+i); 
30.  list.add(emp); 
31.  \} 
32. **return** list; 
33.  \} 
34. \} 
35. 
36. **class** CompanyManager\{ 
37. 
38. **public** List<Employee> getAllEmployee()\{ 
39.  List<Employee> list = **new** ArrayList<Employee>(); 
40. **for**(**int** i=0; i<30; i++)\{ 
41.  Employee emp = **new** Employee(); 
42. //为总公司人员按顺序分配一个ID
43.  emp.setId("总公司"\+i); 
44.  list.add(emp); 
45.  \} 
46. **return** list; 
47.  \} 
48. 
49. **public****void** printAllEmployee(SubCompanyManager sub)\{ 
50.  List<SubEmployee> list1 = sub.getAllEmployee(); 
51. **for**(SubEmployee e:list1)\{ 
52.  System.out.println(e.getId()); 
53.  \} 
54. 
55.  List<Employee> list2 = **this**.getAllEmployee(); 
56. **for**(Employee e:list2)\{ 
57.  System.out.println(e.getId()); 
58.  \} 
59.  \} 
60. \} 
61. 
62. **public****class** Client\{ 
63. **public****static****void** main(String\[\] args)\{ 
64.  CompanyManager e = **new** CompanyManager(); 
65.  e.printAllEmployee(**new** SubCompanyManager()); 
66.  \} 
67. \}

现在这个设计的主要问题出在CompanyManager中，根据迪米特法则，只与直接的朋友发生通信，而SubEmployee类并不是CompanyManager类的直接朋友（以局部变量出现的耦合不属于直接朋友），从逻辑上讲总公司只与他的分公司耦合就行了，与分公司的员工并没有任何联系，这样设计显然是增加了不必要的耦合。按照迪米特法则，应该避免类中出现这样非直接朋友关系的耦合。修改后的代码如下:

**\[java\]** [view plain][] [copy][view plain]

1.  **class** SubCompanyManager\{ 
2.  **public** List<SubEmployee> getAllEmployee()\{ 
3.   List<SubEmployee> list = **new** ArrayList<SubEmployee>(); 
4.  **for**(**int** i=0; i<100; i++)\{ 
5.   SubEmployee emp = **new** SubEmployee(); 
6.  //为分公司人员按顺序分配一个ID
7.   emp.setId("分公司"\+i); 
8.   list.add(emp); 
9.   \} 
10. **return** list; 
11.  \} 
12. **public****void** printEmployee()\{ 
13.  List<SubEmployee> list = **this**.getAllEmployee(); 
14. **for**(SubEmployee e:list)\{ 
15.  System.out.println(e.getId()); 
16.  \} 
17.  \} 
18. \} 
19. 
20. **class** CompanyManager\{ 
21. **public** List<Employee> getAllEmployee()\{ 
22.  List<Employee> list = **new** ArrayList<Employee>(); 
23. **for**(**int** i=0; i<30; i++)\{ 
24.  Employee emp = **new** Employee(); 
25. //为总公司人员按顺序分配一个ID
26.  emp.setId("总公司"\+i); 
27.  list.add(emp); 
28.  \} 
29. **return** list; 
30.  \} 
31. 
32. **public****void** printAllEmployee(SubCompanyManager sub)\{ 
33.  sub.printEmployee(); 
34.  List<Employee> list2 = **this**.getAllEmployee(); 
35. **for**(Employee e:list2)\{ 
36.  System.out.println(e.getId()); 
37.  \} 
38.  \} 
39. \}

修改后，为分公司增加了打印人员ID的方法，总公司直接调用来打印，从而避免了与分公司的员工发生耦合。

迪米特法则的初衷是降低类之间的耦合，由于每个类都减少了不必要的依赖，因此的确可以降低耦合关系。但是凡事都有度，虽然可以避免与非直接的类通信，但是要通信，必然会通过一个“中介”来发生联系，例如本例中，总公司就是通过分公司这个“中介”来与分公司的员工发生联系的。过分的使用迪米特原则，会产生大量这样的中介和传递类，导致系统复杂度变大。所以在采用迪米特法则时要反复权衡，既做到结构清晰，又要高内聚低耦合。

[image]: /images/20220828/bb8757c6f5344ead98d2b16aec405276.png
[image 1]: http://hi.csdn.net/attachment/201105/10/0_13050216726467.gif
[image 2]: http://hi.csdn.net/attachment/201105/10/0_1305021676qgMU.gif
[image_image 2]: /images/20220828/e1d536a847e446ae9801fa50e3823a15.png
[image 3]: http://hi.csdn.net/attachment/201105/10/0_13050216771ktR.gif
[image_image 3]: /images/20220828/30cb306e88fd45d08f2a99a5af989d5f.png
[image 4]: http://hi.csdn.net/attachment/201105/10/0_1305021678K6ev.gif
[image_image 4]: /images/20220828/a44b2deb834c414695bb437837193d2d.png
[image 5]: http://hi.csdn.net/attachment/201105/10/0_1305021681RGop.gif
[image_image 5]: /images/20220828/6b9be70793fe49f98f929a8d88d5f537.png
[image 6]: http://hi.csdn.net/attachment/201105/10/0_1305021681IY6y.gif
[image_image 6]: /images/20220828/52337dafc3ab48c7b8c28dfc9a90adcb.png
[image 7]: http://hi.csdn.net/attachment/201105/10/0_13050216822t0t.gif
[image_image 7]: /images/20220828/04d3e54b8f804850baf75373445447f2.png
[image 8]: http://hi.csdn.net/attachment/201105/10/0_1305021683O1fN.gif
[image_image 8]: /images/20220828/b2cd6af4ee99458f8f89422105b3dfdf.png
[image 9]: http://hi.csdn.net/attachment/201105/10/0_1305021684cR13.gif
[image_image 9]: /images/20220828/191b2929291f48e3bfed5561ec87e4bd.png
[image 10]: http://hi.csdn.net/attachment/201105/10/0_1305021685Taat.gif
[image_image 10]: /images/20220828/f72598937f734133b77e9e9ce6a40c76.png
[image 11]: http://hi.csdn.net/attachment/201105/10/0_1305021686MMmg.gif
[image_image 11]: /images/20220828/0475535df5ef47ddbcff7d1f38ef0046.png
[image 12]: http://hi.csdn.net/attachment/201105/10/0_1305021686p4qA.gif
[image_image 12]: /images/20220828/51f593ddbce5416ea4da721088b4569a.png
[image 13]: http://hi.csdn.net/attachment/201105/10/0_1305021687EaZN.gif
[image_image 13]: /images/20220828/6a92f7fc17464da28bcc8bdb3de9c59f.png
[image 14]: http://hi.csdn.net/attachment/201105/10/0_13050216882du6.gif
[image_image 14]: /images/20220828/61a0255fd244482ebc7e4a452dd5cd6a.png
[image 15]: http://hi.csdn.net/attachment/201105/10/0_1305021689zAew.gif
[image_image 15]: /images/20220828/27245f3a50564fd1b33a85327e691471.png
[view plain]: http://blog.csdn.net/zhengzhb/article/details/7296930#

迪米特法则

发表评论取消回复

还没有评论，来说两句吧...

相关阅读