六大设计原则--迪米特法则【Low Of Demeter】

声明：本文内容是从网络书籍整理而来，并非原创。

定义

迪米特法则也叫做最少知识原则（Least Knowledge Principle），指一个对象应该对其他对象有最少的了解，通俗的讲：一个类对自己需要耦合或者调用的类应该知道的最少，你类内部是怎么复杂、怎么的纠缠不清都和我没关系，那是你的类内部的事情，我只关心你提供的public方法，我可以去调用。

迪米特法则包含以下四层意思：

1. 只和朋友交流。迪米特还有一个英文解释叫做“Only talk to your immedate friends”，只和直接的朋友通信，什么叫做直接的朋友呢？每个对象都必然会和其他对象有耦合关系，两个对象之间的耦合就成为朋友关系，这种关系有很多比如组合、聚合、依赖等等。我们来说个例子说明怎么做到只和朋友交流。

   说是有这么一个故事，老师想让体育委员确认一下全班女生来齐没有，就对他说： “你去把全班女生清一下。 ”体育委员没听清楚，或者是当时脑子正在回忆什么东西，就问道： “亲哪个？”老师￥#……￥%。我们来看这个笑话怎么用程序来实现，先看类图：
   
   Teacher类的代码：

   public class Teacher { 
   
   //老师对学生发布命令,清一下女生 
   public void commond(GroupLeader groupLeader){ 
       List<Girl> listGirls = new ArrayList(); 
       //初始化女生 
       for(int i=0;i<20;i++){ 
           listGirls.add(new Girl()); 
       } 
   
       //告诉体育委员开始执行清查任务 
       groupLeader.countGirls(listGirls); 
   } 
   } 

   老师就有一个方法， 发布命令给体育委员， 去清查一下女生的数量。 下面是体育委员 GroupLeader 类的代码：

   public class GroupLeader { 
   
   //有清查女生的工作 
   public void countGirls(List<Girl> listGirls){ 
       System.out.println("女生数量是："+listGirls.size()); 
   } 
   } 

   我们来看这个业务调用类 Client:：

   public class Client { 
   
   public static void main(String[] args) { 
       Teacher  teacher= new Teacher(); 
   
       //老师发布命令 
       teacher.commond(new GroupLeader()); 
   } 
   } 

   运行的结果如下：

   女生数量是：20
   

   我们回过头来看这个程序有什么问题，首先来看 Teacher有几个朋友，就一个 GroupLeader 类，这个就是朋友类，朋友类是怎么定义的呢？出现在成员变量、方法的输入输出参数中的类被称为成员朋友类，迪米特法则说是一个类只和朋友类交流， 但是commond 方法中我们与 Girl 类有了交流，声明了一个List动态数组，也就是与一个陌生的类 Girl 有了交流，这个不好，那我们再来修改一下，类图还是不变，先修改一下 GroupLeader 类，看代码：

   public class GroupLeader { 
   
   //有清查女生的工作 
   public void countGirls(){ 
       List<Girl> listGirls = new ArrayList<Girl>(); 
       //初始化女生 
       for(int i=0;i<20;i++){ 
           listGirls.add(new Girl()); 
       } 
   
       System.out.println("女生数量是："+listGirls.size()); 
   } 
   } 

   Teacher类代码：

   public class Teacher { 
   
   //老师对学生发布命令,清一下女生 
   public void commond(GroupLeader groupLeader){ 
       //告诉体育委员开始执行清查任务 
       groupLeader.countGirls(listGirls); 
   } 
   } 

   程序做了一个简单的修改，就是把 Teacher 中的对 List初始化（这个是有业务意义的，产生出全班的所有人员）移动到了 GroupLeader的 countGrils 方法中，避开了 Teacher 类对陌生类 Girl的访问，减少系统间的耦合。 记住了， 一个类只和朋友交流， 不与陌生类交流， 不要出现 getA().getB().getC().getD()这种情况（在一种极端的情况下是允许出现这种访问：每一个点号后面的返回类型都相同） ，那当然还要和JDK API 提供的类交流，否则你想脱离编译器存在呀！

2. 朋友间也是有距离的。人和人之间是有距离的，太远就不是朋友了，太近就浑身不自在，这和类间关系也是一样，即使朋友类也不能无话不说，无所不知。大家在项目中应该都碰到过这样的需求：调用一个类，然后必须是先执行第一个方法，然后是第二个方法，根据返回结果再来看是否可以调用第三个方法，或者第四个方法等等，我们用类图表示一下：
   
   Wizard 的代码：

   public class Wizard { 
   private Random rand = new Random(System.currentTimeMillis()); 
   //第一步 
   public int first(){ 
       System.out.println("执行第一个方法..."); 
       return rand.nextInt(100); 
   } 
   
   //第二步 
   public int second(){ 
       System.out.println("执行第二个方法..."); 
       return rand.nextInt(100); 
   } 
   
   //第三个方法 
   public int third(){ 
       System.out.println("执行第三个方法..."); 
       return rand.nextInt(100); 
   } 
   }

   再来看软件安装过程 InstallSoftware 代码：

   public class InstallSoftware { 
   
   public void installWizard(Wizard wizard){ 
       int first = wizard.first();   
       //根据first返回的结果，看是否需要执行second 
       if(first>50){ 
           int second = wizard.second(); 
           if(second>50){ 
               int third = wizard.third(); 
                   if(third >50){ 
                       wizard.first(); 
                   }  
           }  
       } 
   
   } 
   }

   其中 installWizard 就是一个向导式的安装步骤，我们看场景是怎么调用的：

   public class Client { 
   
   public static void main(String[] args) { 
       InstallSoftware invoker = new InstallSoftware(); 
       invoker.installWizard(new Wizard()); 
   } 
   } 

   这个程序很简单，运行结果和随机数有关，我就不粘贴上来了。我们想想这个程序有什么问题吗？Wizard 类把太多的方法暴露给 InstallSoftware类了，这样耦合关系就非常紧了，我想修改一个方法的返回值，本来是 int 的，现在修改为 boolean，你看就需要修改其他的类，这样的耦合是极度不合适的，迪米特法则就要求类“小气”一点，尽量不要对外公布太多的public方法和非静态的public 变量，尽量内敛，多使用private,package-private、protected 等访问权限。我们来修改一下类图：
   
   再来看一下程序的变更，先看 Wizard 程序：

   public class Wizard { 
   private Random rand = new Random(System.currentTimeMillis()); 
   //第一步 
   private int first(){ 
       System.out.println("执行第一个方法..."); 
       return rand.nextInt(100); 
   } 
   
   //第二步 
   private int second(){ 
       System.out.println("执行第二个方法..."); 
       return rand.nextInt(100); 
   } 
   
   //第三个方法 
   private int third(){ 
       System.out.println("执行第三个方法..."); 
       return rand.nextInt(100); 
   } 
   
   //软件安装过程 
   public void installWizard(){     
       int first = this.first();   
       //根据first返回的结果，看是否需要执行second 
       if(first>50){ 
           int second = this.second(); 
               if(second>50){ 
                   int third = this.third(); 
                       if(third >50){ 
                           this.first(); 
                       }  
               }  
       } 
   } 
   }

   三个步骤的访问权限修改为 private，同时把 installeWizad移动的 Wizard 方法中，这样 Wizard 类就对外只公布了一个 public 方法，类的高内聚特定显示出来了。我们再来看 InstallSoftware 源码：

   public class InstallSoftware { 
   
   public void installWizard(Wizard wizard){ 
       //不废话，直接调用 
       wizard.installWizard(); 
   } 
   } 

   Client 类没有任何改变，就不在拷贝了，这样我们的程序就做到了弱耦合，一个类公布越多的 public属性或方法，修改的涉及面也就越大，也就是变更引起的风险就越大。因此为了保持朋友类间的距离，你需要做的是：减少 public 方法，多使用 private、package-private（这个就是包类型，在类、方法、变量前不加访问权限，则默认为包类型）protected等访问权限，减少非 static 的public 属性，如果成员变量或方法能加上 final 关键字就加上，不要让外部去改变它。

3. 是自己的就是自己的。在项目中有一些方法，放在本类中也可以，放在其他类中也没有错误，那怎么去衡量呢？你可以坚持这样一个原则：如果一个方法放在本类中，即不增加类间关系，也对本类不产生负面影响，就放置在本类中。

4. 谨慎使用 Serializable。实话说，这个问题会很少出现的，即使出现也会马上发现问题。是怎么回事呢？举个例子来说，如果你使用 RMI 的方式传递一个对象 VO（Value? Object） ，这个对象就必须使用 Serializable接口，也就是把你的这个对象进行序列化，然后进行网络传输。突然有一天，客户端的VO 对象修改了一个属性的访问权限，从 private 变更为 public 了，如果服务器上没有做出响应的变更的话，就会报序列化失败。这个应该属于项目管理范畴，一个类或接口客户端变更了，而服务端没有变更，那像话吗？！

迪米特法则的核心观念就是类间解耦，弱耦合，只有弱耦合了以后，类的复用率才可以提高，其要求的结果就是产生了大量的中转或跳转类，类只能和朋友交流，朋友少了你业务跑不起来，朋友多了，你项目管理就复杂，大家在使用的时候做相互权衡吧。

不知道大家有没有听过这样一个理论： “任何 2个素不相识的人中间最多只隔着 6个人，即只用 6 个人就可以将他们联系在一起” ，这个理论的学名叫做“六度分离” ，应用到我们项目中就是说我和我要调用的类之间最多有 6 次传递，呵呵，这只能让大家当个乐子来看，在实际项目中你跳两次才访问到一个类估计你就会想办法了，这也是合理的，迪米特法则要求我们类间解耦，但是解耦是有限度的，除非是计算机的最小符号二进制的 0 和1，那才是完全解耦，我们在实际的项目中时，需要适度的考虑这个法则，别为了套用法则而做项目，法则只是一个参考，你跳出了这个法则，也不会有人判你刑，项目也未必会失败，这就需要大家使用的是考虑如何度量法则了。