设计模式六大原则（5）：迪米特法则

迪米特法则：

迪米特法则（Law of Demeter）又叫做最少知识原则（Least Knowledge Principle 简写LKP），就是说一个对象应当对其余对象有尽量少的了解,不和陌生人说话。英文简写为: LoD.

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

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

解决方案：尽可能下降类与类之间的耦合。

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

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67

//总公司员工 class Employee {      private String id ;      public void setId ( String id ) {          this . id = id ;      }      public String getId ( ) {          return id ;      } }   //分公司员工 class SubEmployee {      private String id ;      public void setId ( String id ) {          this . id = id ;      }      public String getId ( ) {          return id ;      } }   class SubCompanyManager {      public List <SubEmployee> getAllEmployee ( ) {          List <SubEmployee> list = new ArrayList <SubEmployee> ( ) ;          for ( int i = 0 ; i < 100 ; i ++ ) {              SubEmployee emp = new SubEmployee ( ) ;              //为分公司人员按顺序分配一个ID              emp . setId ( "分公司" + i ) ;              list . add ( emp ) ;          }          return list ;      } }   class CompanyManager {        public List <Employee> getAllEmployee ( ) {          List <Employee> list = new ArrayList <Employee> ( ) ;          for ( int i = 0 ; i < 30 ; i ++ ) {              Employee emp = new Employee ( ) ;              //为总公司人员按顺序分配一个ID              emp . setId ( "总公司" + i ) ;              list . add ( emp ) ;          }          return list ;      }           public void printAllEmployee ( SubCompanyManager sub ) {          List <SubEmployee> list1 = sub . getAllEmployee ( ) ;          for ( SubEmployee e : list1 ) {              System . out . println ( e . getId ( ) ) ;          }            List <Employee> list2 = this . getAllEmployee ( ) ;          for ( Employee e : list2 ) {              System . out . println ( e . getId ( ) ) ;          }      } }   public class Client {      public static void main ( String [ ] args ) {          CompanyManager e = new CompanyManager ( ) ;          e . printAllEmployee ( new SubCompanyManager ( ) ) ;      } }

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

class SubCompanyManager {      public List <SubEmployee> getAllEmployee ( ) {          List <SubEmployee> list = new ArrayList <SubEmployee> ( ) ;          for ( int i = 0 ; i < 100 ; i ++ ) {              SubEmployee emp = new SubEmployee ( ) ;              //为分公司人员按顺序分配一个ID              emp . setId ( "分公司" + i ) ;              list . add ( emp ) ;          }          return list ;      }      public void printEmployee ( ) {          List <SubEmployee> list = this . getAllEmployee ( ) ;          for ( SubEmployee e : list ) {              System . out . println ( e . getId ( ) ) ;          }      } }   class CompanyManager {      public List <Employee> getAllEmployee ( ) {          List <Employee> list = new ArrayList <Employee> ( ) ;          for ( int i = 0 ; i < 30 ; i ++ ) {              Employee emp = new Employee ( ) ;              //为总公司人员按顺序分配一个ID              emp . setId ( "总公司" + i ) ;              list . add ( emp ) ;          }          return list ;      }           public void printAllEmployee ( SubCompanyManager sub ) {          sub . printEmployee ( ) ;          List <Employee> list2 = this . getAllEmployee ( ) ;          for ( Employee e : list2 ) {              System . out . println ( e . getId ( ) ) ;          }      } }

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

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