你的位置:首页 > Java教程

[Java教程]设计模式原则之迪米特法则

迪米特法则的简写为 LoD,看清楚中间的那个 o 是小写。迪米特法则也叫做做最少知识原则(Least Knowledge Principle,简称 LKP)说的都是一会事,一个对象应该对其他对象有最少的了解,通俗的讲一 个类对自己需要耦合或者调用的类应该知道的最少,你类内部是怎么复杂、怎么的纠缠不清都和我没关系, 那是你的类内部的事情,我就知道你提供的这么多 public 方法,我就调用这个;迪米特法则包含以下四层 意思:

只和朋友交流。迪米特还有一个英文解释叫做“Only talk to your immedate friends”,只和直接 的朋友通信,什么叫做直接的朋友呢?每个对象都必然会和其他对象有耦合关系,两个对象之间的耦合就 成为朋友关系,这种关系有很多比如组合、聚合、依赖等等。我们来说个例子说明怎么做到只和朋友交流。 说是有这么一个故事,老师想让体育委员确认一下全班女生来齐没有,就对他说:“你去把全班女生清 一下。”体育委员没听清楚,或者是当时脑子正在回忆什么东西,就问道:“亲哪个?”老师¥#……¥%。 我们来看这个笑话怎么用程序来实现,先看类图:

Teacher.java 的源程序如下:

package com.cbf4life.common;import java.util.ArrayList;import java.util.List;/*** I'm glad to share my knowledge with you all.* 老师类*/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.java 的源程序:

package com.cbf4life.common;import java.util.List;/*** @author cbf4Life cbf4life@126.com* I'm glad to share my knowledge with you all.* 体育委员,这个太难翻译了都是中国的特色词汇*/public class GroupLeader {//有清查女生的工作public void countGirls(List<Girl> listGirls){ System. out.println(" 女生数量是: "+listGirls.size()); }}

下面是 Girl.java,就声明一个类,没有任何的代码:

package com.cbf4life.common;/*** @author cbf4Life cbf4life@126.com* I'm glad to share my knowledge with you all.* 女生*/public class Girl {}

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

package com.cbf4life.common;/*** @author cbf4Life cbf4life@126.com* I'm glad to share my knowledge with you all.* 我们使用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 类,看源码:

package com.cbf4life.common2;import java.util.ArrayList;import java.util.List;/*** @author cbf4Life cbf4life@126.com* I'm glad to share my knowledge with you all.* 体育委员,这个太难翻译了都是中国的特色词汇*/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.java 程序:

package com.cbf4life.common2;/*** * I'm glad to share my knowledge with you all.* 老师类*/public class Teacher {//老师对学生发布命令, 清一下女生public void commond(GroupLeader groupLeader){ //告诉体育委员开始执行清查任务 groupLeader.countGirls(); }}

 

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

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

 

很简单的类图,实现软件安装过程的第一步做什么、第二步做什么、第三步做什么这样一个过程,我 们来看三个类的源代码,先看 Wizard 的源代码:

 

package com.cbf4life.common3;import java.util.Random;/*** @author cbf4Life cbf4life@126.com* I'm glad to share my knowledge with you all.* 按照步骤执行的业务逻辑类*/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 源码:

package com.cbf4life.common3;/*** @author cbf4Life cbf4life@126.com* I'm glad to share my knowledge with you all.* 业务组装类,负责调用各个步骤*/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 就是一个向导式的安装步骤,我们看场景是怎么调用的:

package com.cbf4life.common3;/*** @author cbf4Life cbf4life@126.com* I'm glad to share my knowledge with you all.* 业务场景*/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 程序:

package com.cbf4life.common4;import java.util.Random;/*** @author cbf4Life cbf4life@126.com* I'm glad to share my knowledge with you all.* 按照步骤执行的业务逻辑类*/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 源码:

package com.cbf4life.common4;/*** @author cbf4Life cbf4life@126.com* I'm glad to share my knowledge with you all.* 业务组装类,负责调用各个步骤*/public class InstallSoftware {public void installWizard(Wizard wizard){ //不废话,直接调用 wizard.installWizard(); }}

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

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

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

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

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