zoukankan      html  css  js  c++  java
  • 单一职责原则 里氏替换原则 依赖倒置原则

    单一职责原则

    http://www.cnblogs.com/cbf4life/archive/2009/12/11/1622166.html

    1.1 我是“牛”类,我可以担任多职吗

         单一职责原则的英文名称是Single Responsibility Principle,简称是SRP。这个设计原则备受争议,只要你想和别人争执、怄气或者是吵架,这个原则是屡试不爽的。如果你是老大,看到一个接口或类是这样或那样设计的,你就问一句:“你设计的类符合SRP原则吗?”,保准对方立马“萎缩”掉,而且还一脸崇拜地看着你,心想:“老大确实英明”。这个原则存在争议之处在哪里呢?就是对职责的定义,什么是类的职责,以及怎么划分类的职责。我们先举个例子来说明什么是单一职责原则。

         只要做过项目,肯定要接触到用户、机构、角色管理这些模块,基本上使用的都是RBAC模型,确实是很好的一个解决办法。我们今天要讲的是用户管理、修改用户的信息、增加机构(一个人属于多个机构)、增加角色等,用户有这么的信息和行为要维护,我们就把这些写到一个接口中,都是用户管理类嘛,我们先来看它的类图,如1-1所示。

    clip_image002

    图1-1 用户信息维护类图

         太Easy的类图了,我相信,即使是一个初级的程序员也可以看出这个接口设计得有问题,用户的属性(Property)和用户的行为(Behavior)没有分开,这是一个严重的错误!非常正确,这个接口确实设计得一团糟,应该把用户的信息抽取成一个BO(Bussiness Object,业务对象),把行为抽取成一个BIZ(Business Logic,业务逻辑),按照这个思路对类图进行修正,如图1-2所示。

    clip_image004

    图1-2 职责划分后的类图

         重新拆封成两个接口,IUserBO负责用户的属性,简单地说,IUserBO的职责就是收集和反馈用户的属性信息;IUserBiz负责用户的行为,完成用户信息的维护和变更。各位可能要说了,这个与我实际工作中用到的User类还是有差别的呀!别着急,我们先来看一看分拆成两个接口怎么使用。OK,我们现在是面向接口编程,所以产生了这个UserInfo对象之后,当然可以把它当IUserBO接口使用。当然,也可以当IUserBiz接口使用,这要看你在什么地方使用了。要获得用户信息,就当是IUserBO的实现类;要是希望维护用户的信息,就把它当作IUserBiz的实现类就成了,如代码清单1-1所示。

    代码清单1-1 分清职责后的代码示例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    .......
     
    IUserBiz userInfo = new UserInfo();
     
    //我要赋值了,我就认为它是一个纯粹的BO
     
    IUserBO userBO = (IUserBO)userInfo;
     
    userBO.setPassword("abc");
     
    //我要执行动作了,我就认为是一个业务逻辑类
     
    IUserBiz userBiz = (IUserBiz)userInfo;
     
    userBiz.deleteUser();
     
    .......

         确实可以如此,问题也解决了,但是我们来回想一下我们刚才的动作,为什么要把一个接口拆分成两个呢?其实,在实际的使用中,我们更倾向于使用两个不同的类或接口:一个是IUserBO, 一个是IUserBiz,类图应该如图1-3所示。

    clip_image006

    图1-3 项目中经常采用的SRP类图

         以上我们把一个接口拆分成两个接口的动作,就是依赖了单一职责原则,那什么是单一职责原则呢?单一职责原则的定义是:应该有且仅有一个原因引起类的变更。

    1.2 绝杀技,打破你的传统思维

         解释到这里,估计你已经很不屑了,“切!这么简单的东西还要讲?!弱智!”好,我们来讲点复杂的。SRP的原话解释是:There should never be more than one reason for a class to change。这句话初中生都能看懂,不多说,但是看懂是一码事,实施就是另外一码事了。上面讲的例子很好理解,在实际项目中大家已经都是这么做了,那我们再来看下面这个例子是否好理解。电话这玩意,是现代人都离不了,电话通话的时候有四个过程发生:拨号、通话、回应、挂机,那我们写一个接口,其类图应该如图1-4所示。

    clip_image008

    图1-4 电话类图

         我不是有意要冒犯IPhone的,同名纯属巧合,我们来看一个这个过程的代码,如代码清单1-2所示。

    代码清单1-2 电话过程

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    public interface IPhone {
     
    //拨通电话
     
    public void dial(String phoneNumber);
     
    //通话
     
    public void chat(Object o);
     
    //回应,只有自己说话而没有回应,那算啥?!
     
    public void answer(Object o);
     
    //通话完毕,挂电话
     
    public void huangup();
     
    }

         实现类也比较简单,我就不再写了,大家看看这个接口有没有问题?我相信大部分的读者都会说这个没有问题呀,以前我就是这么做的呀,某某书上也是这么写的呀,还有什么什么的源码也是这么写的!是的,这个接口接近于完美,看清楚了,是“接近”!单一职责原则要求一个接口或类只有一个原因引起变化,也就是一个接口或类只有一个职责,它就负责一件事情,看看上面的接口只负责一件事情吗?是只有一个原因引起变化吗?好像不是!

         IPhone这个接口可不是只有一个职责,它包含了两个职责:一个是协议管理,一个是数据传送。diag()和huangup()两个方法实现的是协议管理,分别负责拨号接通和挂机;chat()和answer()是数据的传送,把我们说的话转换成模拟信号或数字信号传递到对方,然后再把对方传递过来的信号还原成我们听得懂语言。我们可以这样考虑这个问题,协议接通的变化会引起这个接口或实现类的变化吗?会的!那数据传送(想想看,电话不仅仅可以通话,还可以上网)的变化会引起这个接口或实现类的变化吗?会的!那就很简单了,这里有两个原因都引起了类的变化,而且这两个职责会相互影响吗?电话拨号,我只要能接通就成,甭管是电信的还是网通的协议;电话连接后还关心传递的是什么数据吗?不关心,你要是乐意使用56K的小猫传递一个高清的片子,那也没有问题(顶多有人说你13了)。通过这样的分析,我们发现类图上的IPhone接口包含了两个职责,而且这两个职责的变化不相互影响,那就考虑拆开成两个接口,其类图如图1-5所示。

    clip_image010

    图1-5 职责分明的电话类图

         这个类图看着有点复杂了,完全满足了单一职责原则的要求,每个接口职责分明,结构清晰,但是我相信你在设计的时候肯定不会采用这种方式,一个手机类要把ConnectionManager和DataTransfer组合在一块才能使用。组合是一种强耦合关系,你和我都有共同的生命期,这样的强耦合关系还不如使用接口实现的方式呢,而且还增加了类的复杂性,多了两个类。经过这样的思考后,我们再修改一下类图,如图1-6所示。

    clip_image012

    图1-6 简洁清晰、职责分明的电话类图

         这样的设计才是完美的,一个类实现了两个接口,把两个职责融合在一个类中。你会觉得这个Phone有两个原因引起变化了呀,是的是的,但是别忘记了我们是面向接口编程,我们对外公布的是接口而不是实现类。而且,如果真要实现类的单一职责,这个就必须使用上面的组合模式了,这会引起类间耦合过重、类的数量增加等问题,人为的增加了设计的复杂性。

         通过上面的例子,我们来总结一下单一职责原则有什么好处:

    • 类的复杂性降低,实现什么职责都有清晰明确的定义;
    • 可读性提高,复杂性降低,那当然可读性提高了;
    • 可维护性提高,那当然了,可读性提高,那当然更容易维护了;
    • 变更引起的风险降低,变更是必不可少的,如果接口的单一职责做得好,一个接口修改只对相应的实现类有影响,对其他的接口无影响,这对系统的扩展性、维护性都有非常大帮助。

         看过电话这个例子后,是不是有点反思了,我以前的设计是不是有点的问题了?不,不是的,不要怀疑自己的技术能力,单一职责原则最难划分的就是职责。一个职责一个接口,但问题是“职责”是一个没有量化的标准,一个类到底要负责那些职责?这些职责该怎么细化?细化后是否都要有一个接口或类?这些都需要从实际的项目去考虑,从功能上来说,定义一个IPhone接口也没有错,实现了电话的功能,而且设计还很简单,仅仅一个接口一个实现类,实际的项目我想大家都会这么设计。项目要考虑可变因素和不可变因素,以及相关的收益成本比率,因此设计一个IPhone接口也可能是没有错的。但是,如果纯从“学究”理论上分析就有问题了,有两个可以变化的原因放到了一个接口中,这就为以后的变化带来了风险。如果以后模拟电话升级到数字电话,我们提供的接口IPhone是不是要修改了?接口修改对其他的Invoker类是不是有很大影响?!

         注意 单一职责原则提出了一个编写程序的标准,用“职责”或“变化原因”来衡量接口或类设计得是否有优良,但是“职责”和“变化原因”都是不可度量的,因项目而异,因环境而异。

    1.3 我单纯,所以我快乐

         对于接口,我们在设计的时候一定要做到单一,但是对于实现类就需要多方面考虑了。生搬硬套单一职责原则会引起类的剧增,给维护带来非常多的麻烦,而且过分的细分类的职责也会人为地制造系统的复杂性,本来一个类可以实现的行为硬要拆成两个类,然后使用聚合或组合的方式再耦合在一起,这个是人为制造了系统的复杂性,所以原则是死的,人是活的,这句话是非常好的。

         单一职责原则很难在项目中得到体现,非常难,为什么?在国内,技术人员的地位和话语权都比较低,因此在项目中需要考虑环境,考虑工作量,考虑人员的技术水平,考虑硬件的资源情况,等等,最终妥协的结果是经常违背单一原则。而且,我们中华文明就有很多属于混合型的产物,比如筷子,我们可以把筷子当做刀来使用,分割食物;还可以当叉使用,把食物从盘子中移动到口中。而在西方的文化中,刀就是刀,叉就是叉,你去吃西餐的时候这两样肯定都是有的,刀就是切割食物,叉就是固定食物或者移动食物,分工很明晰。这种文化的差异是很难一步改造过来,但是我相信随着技术的深入,单一职责原则必然会深入到项目的设计中去,而且这个原则是那么的简单,简单得不需要我们更加深入地思考,单从字面上大家都应该知道是什么意思,单一职责嘛!

         单一职责适用于接口、类,同时也适用于方法,什么意思呢?一个方法尽可能做一件事情,比如一个方法修改用户密码,不要把这个方法放到“修改用户信息”方法中,这个方法的颗粒度很粗,比如图1-7中所示的方法。

    clip_image014

    图1-7 一个方法承担多个职责

         在IUserManager中定义了一个方法changeUser,根据传递的类型不同,把可变长度参数changeOptions修改到userBo这个对象上,并调用持久层的方法保存到数据库中。在我的项目组中,如果有人写了这样一个方法,我不管他写了多少程序,花了多少工夫,一律重写!原因很简单:方法职责不清晰,不单一,不要让别人猜测这个方法可能是用来处理什么逻辑。比较好的设计如图1-8所示。

    clip_image016

    图1-8 一个方法承担一个职责

         通过上面的类图,如果要修改用户名称,就调用changeUserName方法;要修改家庭地址,就调用changeHomeAddress方法;要修改单位电话,就调用changeOfficeTel方法。每个方法的职责非常清晰明确,不仅开发简单,而且日后的维护也非常容易,大家可以逐渐养成这样的习惯。

         所以,如果对接口、类、方法使用了单一职责原则,那么快乐的就不仅仅是你了,还有你的项目组成员,大家可以轻松而又愉快地进行开发;还有你的老板,减少了因为变更引起的工作量,减少了无为人员和资金消耗。当然,最快乐的也许就是你了,因为加官进爵可能等着你哟!

    1.4 最佳实践

         你阅读到这里,可能就会问我,你写的是类的设计原则吗?你通篇都在说接口的单一职责,类的单一职责你都违背了呀!呵呵,这个还真是的,我的本意是想把这个原则讲清楚,类的单一职责嘛,这个很简单,但当我回头写的时候,发觉并不是这么回事,翻看了以前的一些设计和代码,基本上拿得出手的类设计都是与单一职责相违背的。静下心来回忆,发觉每一个类这样设计都是有原因的。这几天我查阅了Wikipedia、OODesign等几个网站,专家和我也有类似的经验,基本上类的单一职责都用了类似的一句话来说“This is sometimes hard to see”,这句话翻译过来就是“这个有时候很难说”。是的,类的单一职责确实受非常多因素的制约,纯理论地来讲,这个原则是非常优秀的,但是现实有现实的难处,你必须去考虑项目工期、成本、人员技术水平、硬件情况、网络情况甚至有时候还要考虑政府政策、垄断协议等原因。比如,2004年我就做过一个项目,做加密处理的,甲方就甩过来一句话,你什么都不用管,调用这个API就可以了,不用考虑什么传输协议、异常处理、安全连接等。所以,我们就直接使用了JNI与加密厂商提供的API通信,什么单一职责原则,根本就不用考虑,因为对方不公布通信接口、异常判断。

         对于单一职责原则,我的建议是接口一定要做到单一职责,类的设计尽量做到只有一个原因引起变化。

    里氏替换原则

    http://www.cnblogs.com/cbf4life/archive/2009/12/11/1622245.html

    2.1 爱恨纠葛的父子关系

         在面向对象的语言中,继承是必不可少的、非常优秀的语言机制,它有如下优点:

    • 代码共享,减少创建类的工作量,每个子类都拥有父类的方法和属性;
    • 提高代码的重用性;
    • 子类可以形似父类,但又异于父类,“龙生龙,凤生凤,老鼠生来会打洞”是说子拥有父的“种”,“世界上没有两片完全相同的叶子”是指明子与父的不同;
    • 提高代码的可扩展性,实现父类的方法就可以“为所欲为”了,君不见很多开源框架的扩展接口都是通过继承父类来完成的;
    • 提高产品或项目的开放性。

         自然界的所有事物都是优点和缺点并存的,即使是鸡蛋,有时候也能挑出骨头来,继承的缺点如下:

    • 继承是侵入性的。只要继承,就必须拥有父类的所有属性和方法;
    • 降低代码的灵活性。子类必须拥有父类的属性和方法,让子类自由的世界中多了些约束;
    • 增强了耦合性。当父类的常量、变量和方法被修改时,必需要考虑子类的修改,而且在缺乏规范的环境下,这种修改可能带来非常糟糕的结果——大片的代码需要重构。

         Java使用extends关键字来实现继承,它采用了单一继承的规则,C++则采用了多重继承的规则,一个子类可以继承多个父类。从整体上来看,利大于弊,怎么才能让“利”的因素发挥最大的作用,同时减少“弊”带来的麻烦呢?解决方案是引入里氏替换原则(Liskov Substitution Principle,简称LSP),什么是里氏替换原则呢?它有两种定义:

         第一种定义,最正宗的定义:If for each object o1 of type S there is an object o2 of type T such that for all programs P defined in terms of T, the behavior of P is unchanged when o1 is substituted for o2 then S is a subtype of T.

         如果对每一个类型为T1的对象o1,都有类型为T2的对象o2,使得以T1定义的所有程序P在所有的对象o1都代换成o2时,程序P的行为没有发生变化,那么类型T2是类型T1的子类型。

         第二种定义,functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it.

         所有引用基类的地方必须能透明地使用其子类的对象。

         第二个定义是最清晰明确的,通俗点讲,只要父类能出现的地方子类就可以出现,而且替换为子类还不产生任何错误或异常,使用者可能根本就不需要知道是父类还是子类。但是,反过来就不行了,有子类出现的地方,父类未必就能适应。

    2.2 纠纷不断,规则压制

         里氏替换原则为良好的继承定义了一个规范,一句简单的定义包含了四层含义:

    • 子类必须完全实现父类的方法

         我们在做系统设计时,经常会定义一个接口或抽象类,然后编码实现,调用类则直接传入接口或抽象类,其实这里已经使用了里氏替换原则。我们举个例子来说明这个原则,大家都打过CS吧,非常经典的FPS类游戏,我们来描述一下里面用到的枪,类图如图2-1所示。

    clip_image002

    图2-1 CS游戏中的枪械类图

         枪的主要职责是射击,如何射击在各个具体的子类中定义,手 枪是单发射程比较近,步枪威力大射程远,机枪用于扫射。在士兵类中定义了一个方法killEnemy,使用枪来杀敌人,具体使用什么枪来杀敌人,调用的时候才知道,AbstractGun类的源程序如代码清单2-1所示。

    代码清单2-1 枪支的抽象类

    1
    2
    3
    4
    5
    6
    7
    public abstract class AbstractGun {
     
    //枪用来干什么的?射击杀戮!
     
    public abstract void shoot();
     
    }

         手 枪、步枪、机枪的实现类如代码清单2-2所示。

    代码清单2-2 手 枪、步枪、机枪的实现类

    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
    public class Handgun extends AbstractGun {
     
    //手 枪的特点是携带方便,射程短
     
    @Override
     
    public void shoot() {
     
    System.out.println("手 枪射击...");
     
    }
     
    }
     
    public class Rifle extends AbstractGun{
     
    //步枪的特点是射程远,威力大
     
    public void shoot(){
     
    System.out.println("步枪射击...");
     
    }
     
    }
     
    public class MachineGun extends AbstractGun{
     
    public void shoot(){
     
    System.out.println("机枪扫射...");
     
    }
     
    }

         有了枪械,还要有能够使用这些枪械的士兵,其源程序如代码清单2-3所示。

    代码清单2-3 士兵的实现类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class Soldier {
     
    public void killEnemy(AbstractGun gun){
     
    System.out.println("士兵开始杀人...");
     
    gun.shoot();
     
    }
     
    }

         注意粗体部分,定义士兵使用枪来杀敌,但是这把枪是时抽象的,具体是手 枪还是步枪需要在上战场前(也就是场景中)前确定。场景类Client的源代码如代码清单2-4所示。

    代码清单2-4 场景类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public class Client {
     
    public static void main(String[] args) {
     
    //产生三毛这个士兵
     
    Soldier sanMao = new Soldier();
     
    sanMao.killEnemy(new Rifle());
     
    }
     
    }

         有人,有枪,也有场景,运行结果如下所示。

    士兵开始杀人...

    步枪射击...

         在这个程序中,我们给三毛这个士兵一把步枪,然后就开始杀敌了,如果三毛要使用机枪当然也可以,直接把sanMao.killEnemy(new Rifle())修改为 sanMao.killEnemy(newMachineGun())就可以了,在编写程序时Solider士兵类根本就不用知道是哪个型号的枪(子类)被传入。

         注意 在类中调用其他类时务必要使用父类或接口,如果不能使用父类或接口,则说明类的设计已经违背了LSP原则。

         我们再来想一想,如果我们有一个玩具手 枪,该如何定义呢?我们先在类图2-1上增加一个类ToyGun,然后继承于AbstractGun类,修改后的类图如图2-2所示。

    clip_image004

    图2-2 枪械类图

         首先我们想,玩具枪是不能用来射击的,杀不死人的,这个不应该写在shoot方法中。新增加的ToyGun的源代码如代码清单2-5所示。

    代码清单2-5 玩具枪源代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public class ToyGun extends AbstractGun {
     
    //玩具枪是不能射击的,但是编译器又要求实现这个方法,怎么办?虚构一个呗!
     
    @Override
     
    public void shoot() {
     
    //玩具枪不能射击,这个方法就不实现了
     
    }
     
    }

         由于引入了新的子类,场景类中也使用了该类,Client稍作修改,源代码如代码清单2-6所示。

    代码清单2-6 玩具枪源代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public class Client {
     
    public static void main(String[] args) {
     
    //产生三毛这个士兵
     
    Soldier sanMao = new Soldier();
     
    sanMao.killEnemy(new ToyGun());
     
    }
     
    }

         修改了黑体部分,把玩具枪传递给三毛用来杀敌,代码运行结果如下所示:

    士兵开始杀人...

         坏了,士兵拿着玩具枪来杀人,射不出子弹呀!如果在CS游戏中有这种事情发生,那你就等着被人爆头吧,然后看着自己凄凉的倒地。在这种情况下,我们发现业务调用类已经出现了问题,正常的业务逻辑已经不能运行,那怎么办?好办,有两种解决办法:

         Number one:在Soldier类中增加instanceof的判断,如果是玩具枪,就不用来杀敌人。这个方法可以解决问题,但是你要知道,在程序中,每增加一个类,所有与这个父类有关系的类都必须修改,你觉得可行吗?如果你的产品出现了这个问题,因为修正了这样一个Bug,就要求所有与这个父类有关系的类都增加一个判断,客户非跳起来跟你干架不可!你还想要你的客户忠诚你吗?显然,这个方案被否定了。

         Number two:ToyGun脱离继承,建立一个独立的父类,为了做到代码可以复用,可以与AbastractGun建立关联委托关系,如图2-3所示。

    clip_image006

    图2-3 玩具枪与真实枪分离的类图

         例如,可以在AbstractToy中声明声音、形状都委托给AbstractGun处理,仿真枪嘛,形状和声音都要和真实的枪一样了,然后两个基类下的子类自由延展,互不影响。

         在Java的基础知识中,每位老师都会讲继承,Java的三大特征嘛,继承、封装、多态。继承就是告诉你拥有父类的方法和属性,然后你就可以重写父类的方法。按照继承原则,我们上面的玩具枪继承AbstractGun是绝对没有问题的,玩具枪也是枪嘛,但是在具体应用场景中就要考虑下面这个问题了:子类是否能够完整地实现父类的业务,否则就会出现像上面的拿枪杀敌人时却发现是把玩具枪的笑话。

         注意 如果子类不能完整地实现父类的方法,或者父类的某些方法在子类中已经发生“畸变”,则建议断开父子继承关系,采用依赖、聚集、组合等关系代替继承。

    • 子类可以有自己的个性

         子类当然可以有自己的行为和外观了,也就是方法和属性,那这里为什么要再提呢?是因为里氏替换原则可以正着用,但是不能反过来用。在子类出现的地方,父类未必就可以胜任。还是以刚才的关于枪械的例子为例,步枪有几个比较“响亮”的型号,比如AK47、G3狙击步枪等,把这两个型号的枪引入后的Rifle子类图如图2-4所示。

    clip_image008

    图2-4 增加AK47和G3后的Rifle子类图

         很简单,G3继承了Rifle类,狙击手(Snipper)则直接使用G3狙击步枪,源代码如代码清单2-7所示。

    代码清单2-7 G3狙击枪源码代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    public class G3 extends Rifle {
     
    //狙击枪都是携带一个精准的望远镜
     
    public void zoomOut(){
     
    System.out.println("通过望远镜查看敌人...");
     
    }
     
    public void shoot(){
     
    System.out.println("G3射击...");
     
    }
     
    }

         有狙击枪就有狙击手,狙击手类的源代码如代码清单2-8所示。

    代码清单2-8 G3狙击手类的源码代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    public class Snipper {
     
    public void killEnemy(G3 g3){
     
    //首先看看敌人的情况,别杀死敌人,自己也被人干掉
     
    g3.zoomOut();
     
    //开始射击
     
    g3.shoot();
     
    }
     
    }

         狙击手,为什么叫Snipper?Snipe翻译过来就是鹬,就是鹬蚌相争,渔翁得利中的那个动物,英国贵族到印度打猎,发现这个鹬很聪明,人一靠近就飞走了,没办法就开始伪装、远程精准射击,于是乎Snipper就诞生了。

         狙击手使用狙击枪来杀死敌人,业务场景Client类的源代码如代码清单2-9所示。

    代码清单2-9 狙击手使用G3杀死敌人

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public class Client {
     
    public static void main(String[] args) {
     
    //产生三毛这个狙击手
     
    Snipper sanMao = new Snipper();
     
    sanMao.killEnemy(new G3());
     
    }
     
    }

          狙击手使用G3杀死敌人,运行结果如下所示:

    通过望远镜查看敌人...

    G3射击...

          在这里系统直接调用了子类,一个狙击手是很依赖枪支的,别说换一个型号的枪了,就是换一个同型号的枪也会影响射击,所以这里就直接把子类传递了进来。这个时候,我们能不能直接使用父类传递进来呢?修改一下Client类,如代码清单2-10所示。

    代码清单2-10 使用父类作为参数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    public class Client {
     
    public static void main(String[] args) {
     
    //产生三毛这个狙击手
     
    Snipper sanMao = new Snipper();
     
    Rifle rifle = new Rifle();
     
    sanMao.killEnemy((G3)rifle);
     
    }
     
    }

          显示是不行的,会在运行期抛出java.lang.ClassCastException异常,这也是大家经常说的向下转型(downcast)是不安全的,从里氏替换原则来看,就是有子类出现的地方父类未必就可以出现。

    • 覆盖或实现父类的方法时输入参数可以被放大

          方法中的输入参数称为前置条件,这是什么意思呢?大家做过Web Service开发就应该知道有一个“契约优先”的原则,也就是先定义出WSDL接口,制定好双方的开发协议,然后再各自实现。里氏替换原则也要求制定一个契约,就是父类或接口,这种设计方法也叫做Design by Contract,契约设计,是与里氏替换原则融合在一起的。契约制定了,也就同时制定了前置条件和后置条件,前置条件就是你要让我执行,就必须满足我的条件;后置条件就是我执行完了需要反馈,标准是什么。这个比较难理解,我们来看一个例子,我们先定义个Father类,如代码清单2-11所示。

    代码清单2-11 Father类源代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class Father {
     
    public Collection doSomething(HashMap map){
     
    System.out.println("父类被执行...");
     
    return map.values();
     
    }
     
    }

          这个类非常简单,就是把HashMap转换为Collection集合类型,然后再定义一个子类,源代码如代码清单2-12所示。

    代码清单2-12 子类源代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public class Son extends Father {
     
    //放大输入参数类型
     
    public Collection doSomething(Map map){
     
    System.out.println("子类被执行...");
     
    return map.values();
     
    }
     
    }

          请注意粗体部分,与父类的方法名相同,但又不是覆写(Override)父类的方法。你加个@Override试试看,会报错的,为什么呢?方法名虽然相同,但方法的输入参数不同,就不是覆写,那这是什么呢?是重载(Overload)!不用大惊小怪的,不在一个类就不能是重载了?继承是什么意思,子类拥有父类的所有属性和方法,方法名相同,输入参数类型又不相同,当然是重载了。父类和子类都已经声明了,场景类的调用如代码清单2-13所示。

    代码清单2-13 场景类源代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    public class Client {
     
    public static void invoker(){
     
    //父类存在的地方,子类就应该能够存在
     
    Father f = new Father();
     
    HashMap map = new HashMap();
     
    f.doSomething(map);
     
    }
     
    public static void main(String[] args) {
     
    invoker();
     
    }
     
    }

          代码运行后的结果如下所示:

    父类被执行...

          根据里氏替换原则,父类出现的地方子类就可以出现,我们把上面的粗体部分修改为子类,如下代码清单2-14所示。

    代码清单2-14 子类替换父类后的源代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    public class Client {
     
    public static void invoker(){
     
    //父类存在的地方,子类就应该能够存在
     
    Son f =new Son();
     
    HashMap map = new HashMap();
     
    f.doSomething(map);
     
    }
     
    public static void main(String[] args) {
     
    invoker();
     
    }
     
    }

          运行结果还是一样,看明白是怎么回事了吗?父类方法的输入参数是HashMap类型,子类的输入参数是Map类型,也就是说子类的输入参数类型的范围扩大了,子类代替父类传递到调用者中,子类的方法永远都不回被执行。这是正确的,如果你想让子类的方法运行,就必须覆写父类的方法。大家可以这样想,在一个Invoker类中关联了一个父类,调用了一个父类的方法,子类可以覆写这个方法,也可以重载这个方法,前提是要扩大这个前置条件,就是输入参数的类型大于父类的类型覆盖范围。这样说可能比较理难理解,我们再反过来想一下,如果Father类的输入参数类型大于子类的输入参数类型,会出现什么问题呢?会出现父类存在的地方,子类就未必可以存在,因为一旦把子类作为参数传入,调用者就很可能进入子类的方法范畴。我们把上面的例子修改一下,扩大父类的前置条件,源代码如代码清单2-15所示。

    代码清单2-15 父类的前置条件较大

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class Father {
     
    public Collection doSomething(Map map){
     
    System.out.println("Map 转Collection被执行");
     
    return map.values();
     
    }
     
    }

          把父类的前置条件修改为Map类型,我们再修改一下子类方法的输入参数,相对父类缩小输入参数的类型范围,也就是缩小前置条件,源代码如代码清单2-16所示。

    代码清单2-16 子类的前置条件较小

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public class Son extends Father {
     
    //缩小输入参数范围
     
    public Collection doSomething(HashMap map){
     
    System.out.println("HashMap转Collection被执行...");
     
    return map.values();
     
    }
     
    }

          在父类的前置条件大于子类的前置条件的情况下,业务场景的源代码如代码清单2-17所示。

    代码清单2-17 子类的前置条件较小

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    public class Client {
     
    public static void invoker(){
     
    //有父类的地方就有子类
     
    Father f= new Father();
     
    HashMap map = new HashMap();
     
    f.doSomething(map);
     
    }
     
    public static void main(String[] args) {
     
    invoker();
     
    }
     
    }

          代码运行结果如下所示:

    父类被执行...

          那我们再把里氏替换原则引入进来会有什么问题?有父类的地方子类就可以使用,好,我们把这个Client类修改一下,源代码如代码清单2-18所示。

    代码清单2-18 采用里氏替换原则后的业务场景类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    public class Client {
     
    public static void invoker(){
     
    //有父类的地方就有子类
     
    Son f =new Son();
     
    HashMap map = new HashMap();
     
    f.doSomething(map);
     
    }
     
    public static void main(String[] args) {
     
    invoker();
     
    }
     
    }

          代码运行后的结果如下所示:

    子类被执行...

          完蛋了吧?!子类在没有覆写父类的方法的前提下,子类方法被执行了,这会引起业务逻辑混乱,因为在实际应用中父类一般都是抽象类,子类是实现类,你传递一个这样的实现类就会“歪曲”了父类的意图,引起一堆意想不到的业务逻辑混乱,所以子类中方法的前置条件必须与超类中被覆盖的方法的前置条件相同或者更宽松。

    • 覆盖或实现父类的方法时输出结果可以被缩小

          这是什么意思呢,父类的一个方法的返回值是一个类型T,子类的相同方法(重载或覆写)的返回值为S,那么里氏替换原则就要求S必须小于等于T,也就是说要么S和T是同一个类型,要么S是T的子类,为什么呢?分两种情况,如果是覆写,父类和子类的同名方法的输入参数是相同的,两个方法的范围值S小于等于T,这是覆写的要求,这才是重中之重,子类覆写父类的方法,天经地义。如果是重载,则要求方法的输入参数类型或数量不相同,在里氏替换原则要求下,就是子类的输入参数大于或等于父类的输入参数,也就是说你写的这个方法是不会被调用到的,参考上面讲的前置条件。

          采用里氏替换原则的目的就是增强程序的健壮性,版本升级时也可以保持非常好的兼容性。即使增加子类,原有的子类还可以继续运行。在实际项目中,每个子类对应不同的业务含义,使用父类作为参数,传递不同的子类完成不同的业务逻辑,非常完美!

    2.3 最佳实践

          在项目中,采用里氏替换原则时,尽量避免子类的“个性”,一旦子类有“个性”,这个子类和父类之间的关系就很难调和了,把子类当做父类使用,子类的“个性”被抹杀——委屈了点;把子类单独作为一个业务来使用,则会让代码间的耦合关系变得扑朔迷离——缺乏类替换的标准。

     

    http://www.cnblogs.com/cbf4life/archive/2009/12/15/1624435.html

    3.1 依赖倒置原则的定义

         依赖倒置原则(Dependence Inversion Principle,简称DIP)这个名字看着有点别扭,“依赖”还“倒置”,这到底是什么意思?依赖倒置原则的原始定义是:High level modules should not depend upon low level modules. Both should depend upon abstractions. Abstractions should not depend upon details. Details should depend upon abstractions。翻译过来,包含三层含义:

    • 高层模块不应该依赖低层模块,两者都应该依赖其抽象;
    • 抽象不应该依赖细节;
    • 细节应该依赖抽象。

         高层模块和低层模块容易理解,每一个逻辑的实现都是由原子逻辑组成的,不可分割的原子逻辑就是低层模块,原子逻辑的再组装就是高层模块。那什么是抽象,什么又是细节呢?在Java语言中,抽象就是指接口或抽象类,两者都是不能直接被实例化的;细节就是实现类,实现接口或继承抽象类而产生的类就是细节,其特点就是可以直接被实例化,也就是可以加上一个关键字new产生一个对象。依赖倒置原则在Java语言中的表现就是:

    • 模块间的依赖是通过抽象发生,实现类之间不发生直接的依赖关系,其依赖关系是通过接口或抽象类产生的;
    • 接口或抽象类不依赖于实现类;
    • 实现类依赖接口或抽象类。

         更加精简的定义就是“面向接口编程”——OOD(Object-Oriented Design,面向对象设计)的精髓之一。

    3.2 言而无信,你太需要契约

         采用依赖倒置原则可以减少类间的耦合性,提高系统的稳定性,减少并行开发引起的风险,提高代码的可读性和可维护性。

         证明一个定理是否正确,有两种常用的方法:一种是根据提出的论题,经过一番论证,推出和定理相同的结论,这是顺推证法;还有一种是首先假设提出的命题是伪命题,然后推导出一个荒谬、与已知条件互斥的结论,这是反证法。我们今天就用反证法来证明依赖倒置原则是多么的优秀和伟大!

         论题:依赖倒置原则可以减少类间的耦合性,提高系统的稳定性,减少并行开发引起的风险,提高代码的可读性和维护性。

         反论题:不使用依赖倒置原则也可以减少类间的耦合性,提高系统的稳定性,减少并行开发引起的风险,提高代码的可读性和维护性。

         我们通过一个例子来说明反论题是不成立的。现在的汽车越来越便宜了,也就顶多一个卫生间的价格就可以买到一辆不错的汽车,有汽车就必然有人来驾驶了,司机驾驶奔驰车的类图如图3-1所示。

    clip_image002

    图3-1 司机驾驶奔驰车类图

         奔驰车可以提供一个方法run,代表车辆运行,实现过程如代码清代3-1所示。

    代码清单3-1 司机源代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class Driver {
     
    //司机的主要职责就是驾驶汽车
     
    public void drive(Benz benz){
     
    benz.run();
     
    }
     
    }

         司机通过调用奔驰车的run方法开动奔驰车,其源代码如代码清单3-2所示。

    代码清单3-2 奔驰车源代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class Benz {
     
    //汽车肯定会跑
     
    public void run(){
     
    System.out.println("奔驰汽车开始运行...");
     
    }
     
    }

         有车,有司机,在Client场景类产生相应的对象,其源代码如代码清代3-3所示。

    代码清单3-3 场景类源代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    public class Client {
     
    public static void main(String[] args) {
     
    Driver zhangSan = new Driver();
     
    Benz benz = new Benz();
     
    //张三开奔驰车
     
    zhangSan.drive(benz);
     
    }
     
    }

         通过以上的代码,完成了司机开动奔驰车的场景,到目前为止,这个司机开奔驰车的项目没有任何问题。我们常说“危难时刻见真情”,我们把这句话移植到技术上就成了“变更才显真功夫”,业务需求变更永无休止,技术前进就永无止境,在发生变更时才能发觉我们的设计或程序是否是松耦合。我们在一段貌似磐石的程序上加上一块小石头:张三司机不仅要开奔驰车,还要开宝马车,又该怎么实现呢?麻烦出来了,那好,我们走一步是一步,我们先把宝马车产生出来,实现过程如代码清单3-4所示。

    代码清单3-4 宝马车源代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class BMW {
     
    //宝马车当然也可以开动了
     
    public void run(){
     
    System.out.println("宝马汽车开始运行...");
     
    }
     
    }

         宝马车也产生了,但是我们却没有办法让张三开动起来,为什么?张三没有开动宝马车的方法呀!一个拿有C照的司机竟然只能开奔驰车而不能开宝马车,这也太不合理了!在现实世界都不允许存在这种情况,何况程序还是对现实世界的抽象,我们的设计出现了问题:司机类和奔驰车类之间是一个紧耦合的关系,其导致的结果就是系统的可维护性大大降低,可读性降低,两个相似的类需要阅读两个文件,你乐意吗?还有稳定性,什么是稳定性?固化的、健壮的才是稳定的,这里只是增加了一个车类就需要修改司机类,这不是稳定性,这是易变性。被依赖者的变更竟然让依赖者来承担修改的成本,这样的依赖关系谁肯承担!证明到这里,我们已经知道伪命题已经部分不成立了。

         注意 设计是否具备稳定性,只要适当的“松松土”,观察“设计的蓝图”是否还可以茁壮的成长就可以得出结论,稳定性较高的设计,在周围环境频繁变化的时候,依然可以做到“我自岿然不动”。

         我们继续证明,“减少并行开发引起的风险”,什么是并行开发的风险?并行开发最大的风险就是风险扩散,本来只是一段程序的错误或异常,逐步波及一个功能,一个模块,甚至到最后毁坏了整个项目,为什么并行开发就有这个风险呢?一个团队,20人开发,各人负责不同的功能模块,甲负责汽车类的建造,乙负责司机类的建造,在甲没有完成的情况下,乙是不能完全地编写代码的,缺少汽车类,编译器根本就不会让你通过!在缺少Benz类的情况下,Driver类能编译吗?更不要说是单元测试了!在这种不使用依赖倒置原则的环境中,所有的开发工作都是“单线程”的,甲做完,乙再做,然后是丙继续…,这在90年代“个人英雄主义”编程模式中还是比较适用的,一个人完成所有的代码工作,但在现在的大中型项目中已经是完全不能胜任了,一个项目是一个团队的协作结果,一个“英雄”再牛X也不可能了解所有的业务和所有的技术,要协作就要并行开发,要并行开发就要解决模块之间的项目依赖关系,那然后呢?依赖倒置原则就隆重出场了!

         根据以上证明,如果不使用依赖倒置原则就会加重类间的耦合性,降低系统的稳定性,增加并行开发引起的风险,降低代码的可读性和维护性。承接上面的例子,引入依赖倒置原则后的类图如图3-2所示。

    clip_image004

    图3-2 引入依赖倒置原则后的类图

         建立两个接口:IDriver和ICar,分别定义了司机和汽车的各个职能,司机就是驾驶汽车,必须实现drive()方法,其实现过程如代码清单3-5所示。

    代码清单3-5 司机接口

    1
    2
    3
    4
    5
    6
    7
    public interface IDriver {
     
    //是司机就应该会驾驶汽车
     
    public void drive(ICar car);
     
    }

         接口只是一个抽象化的概念,是对一类事物的最抽象描述,具体的实现代码由相应的实现类来完成,Driver实现类如代码清单3-6所示。

    代码清单3-6 司机类的实现

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class Driver implements IDriver{
     
    //司机的主要职责就是驾驶汽车
     
    public void drive(ICar car){
     
    car.run();
     
    }
     
    }

         在IDriver中,通过传入ICar接口实现了抽象之间的依赖关系,Driver实现类也传入了ICar接口,至于到底是哪个型号的Car需要在高层模块中声明。

         ICar及其两个实现类的实现过程如代码清单3-7所示。

    代码清单3-7 汽车接口及两个实现类

    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
    public interface ICar {
     
    //是汽车就应该能跑
     
    public void run();
     
    }
     
    public class Benz implements ICar{
     
    //汽车肯定会跑
     
    public void run(){
     
    System.out.println("奔驰汽车开始运行...");
     
    }
     
    }
     
    public class BMW implements ICar{
     
    //宝马车当然也可以开动了
     
    public void run(){
     
    System.out.println("宝马汽车开始运行...");
     
    }
     
    }

         在业务场景中,我们贯彻“抽象不应该依赖细节”,也就是我们认为抽象(ICar接口)不依赖BMW和Benz两个实现类(细节),因此我们在高层次的模块中应用都是抽象,Client的实现过程如代码清单3-8所示。

    代码清单3-8 业务场景

    public class Client {

    public static void main(String[] args) {

    IDriver zhangSan = new Driver();

    ICar benz = new Benz();

    //张三开奔驰车

    zhangSan.drive(benz);

    }

    }

         Client属于高层业务逻辑,它对低层模块的依赖都建立在抽象上,zhangSan的显示类型是IDriver,benz的显示类型是ICar,也许你要问,在这个高层模块中也调用到了低层模块,比如new Driver()和new Benz()等,如何解释?确实如此,zhangSan的显示类型是IDriver,是一个接口,是抽象的,非实体化的,在其后的所有操作中,zhangSan都是以IDriver类型进行操作,屏蔽了细节对抽象的影响。当然,张三如果要开宝马车,也很容易,我们只要修改业务场景类就可以,实现过程如代码清单3-9所示。

    代码清单3-9 张三驾驶宝马车的实现过程

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    public class Client {
     
    public static void main(String[] args) {
     
    IDriver zhangSan = new Driver();
     
    ICar bmw = new BMW();
     
    //张三开奔驰车
     
    zhangSan.drive(bmw);
     
    }
     
    }

         在新增加低层模块时,只修改了业务场景类,也就是高层模块,对其他低层模块如Driver类不需要做任何修改,业务就可以运行,把“变更”引起的风险扩散降低到最小。

         注意 在Java中,只要定义变量就必然要有类型,一个变量可以有两个类型:显示类型和真实类型,显示类型是在定义的时候赋予的类型,真实类型是对象的类型,如zhangSan的显示类型是IDriver,真实类型是Driver。

         我们再来思考依赖倒转对并行开发的影响。两个类之间有依赖关系,只要制定出两者之间的接口(或抽象类)就可以独立开发了,而且项目之间的单元测试也可以独立的运行,而TDD(Test-Driven Development,测试驱动开发)开发模式就是依赖倒置原则的最高级应用。我们继续回顾上面司机驾驶汽车的例子,甲程序员负责IDriver的开发,乙程序员负责ICar的开发,两个开发人员只要制定好了接口就可以独立地开发了,甲开发进度比较快,完成了IDriver以及相关的实现类Driver的开发工作,而乙程序员滞后开发,那甲是否可以进行单元测试(Unit Test)呢?答案是可以,我们引入一个JMock工具,其最基本的功能是根据抽象虚拟一个对象进行测试,测试类如代码清单3-10所示。

    代码清单3-10 测试类

    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
    public class DriverTest extends TestCase{
     
    Mockery context = new JUnit4Mockery();
     
    @Test
     
    public void testDriver() {
     
    //根据接口虚拟一个对象
     
    final ICar car = context.mock(ICar.class);
     
    IDriver driver = new Driver();
     
    //内部类
     
    context.checking(new Expectations(){{
     
    oneOf (car).run();
     
    }});
     
    driver.drive(car);
     
    }
     
    }

         注意粗体部分,我们只需要一个ICar的接口,就可以对Driver类进行单元测试,从这一点来看,两个相互依赖的对象可以分别进行开发,孤立的单元测试,进而保证并行开发的效率和质量,TDD开发的精髓不就在这里吗?测试驱动开发,先写好单元测试类,然后再写实现类,这对代码的质量有非常大的提高,特别适合研发类项目或在项目成员整体水平比较低的情况下采用。

         抽象是对实现的约束,对依赖者而言,也是一种契约,不仅仅约束自己,还同时约束自己与外部的关系,其目的是保证所有的细节不逃脱契约的范畴,确保约束双方按照既定的契约(抽象)共同发展,只要抽象这根基线在,细节就逃脱不了这个圈圈,始终让你的对象做到“言而有信”“言出必行”

    3.3 依赖的三种写法

         依赖是可以传递的,A对象依赖B对象,B又依赖C,C又依赖D…,生生不息,依赖不止,记住一点:只要做到抽象依赖,即使是多层的依赖传递也无所畏惧!

         对象的依赖关系有三种方式来传递,如下所示。

    • 构造函数传递依赖对象

         在类中通过构造函数声明依赖对象,按照依赖注入的说法这种方式叫做构造函数注入,按照这种方式的注入,IDriver和Driver的程序修改后如代码清单3-11所示。

    代码清单3-11 构造函数传递依赖对象

    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
    public interface IDriver {
     
    //是司机就应该会驾驶汽车
     
    public void drive();
     
    }
     
    public class Driver implements IDriver{
     
    private ICar car;
     
    //构造函数注入
     
    public Driver(ICar _car){
     
    this.car = _car;
     
    }
     
    //司机的主要职责就是驾驶汽车
     
    public void drive(){
     
    this.car.run();
     
    }
     
    }
    • Setter方法传递依赖对象

         在抽象中设置setter方法声明依赖关系,依照依赖注入的说法就是setter依赖注入,按照这种方式的注入,IDriver和Driver的程序修改后如代码清单3-12所示。

    代码清单3-12 Setter依赖注入

    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
    public interface IDriver {
     
    //车辆型号
     
    public void setCar(ICar car);
     
    //是司机就应该会驾驶汽车
     
    public void drive();
     
    }
     
    public class Driver implements IDriver{
     
    private ICar car;
     
    public void setCar(ICar car){
     
    this.car = car;
     
    }
     
    //司机的主要职责就是驾驶汽车
     
    public void drive(){
     
    this.car.run();
     
    }
     
    }
    • 接口声明依赖对象

         在接口的方法中声明依赖对象,3.2章节的例子就是采用了接口声明依赖的方式,,该方法也叫做接口注入。

    3.4 最佳实践

         依赖倒转原则的本质就是通过抽象(接口或抽象类)使各个类或模块的实现彼此独立,不互相影响,实现模块间的松耦合,我们怎么在项目中使用这个规则呢?只要遵循以下的几个规则就可以:

    • 每个类尽量都有接口或抽象类,或者抽象类和接口两者都具备。

         这是依赖倒置的基本要求,接口和抽象类都是属于抽象的,有了抽象才可能依赖倒置。

    • 变量的显示类型尽量是接口或者是抽象类。

         很多书上说变量的类型一定要是接口或者是抽象类,这个有点绝对化了,比如一个工具类,xxxUtils一般是不需要接口或是抽象类的。还有,如果你要使用类的clone方法,就必须使用实现类,这个是JDK提供一个规范。

    • 任何类都不应该从具体类派生。

         如果一个项目处于开发状态,确实不应该有从具体类派生出的子类的情况,但这也不是绝对的,因为人都是会犯错误的,有时设计缺陷是在所难免的,因此只要不超过两层的继承都是可以忍受的。特别是做项目维护的同志,基本上可以不考虑这个规则,为什么?维护工作基本上都是做扩展开发,修复行为,通过一个继承关系,覆写一个方法就可以修正一个很大的Bug,何必再要去继承最高的基类呢?

    • 尽量不要覆写基类的方法。

         如果基类是一个抽象类,而且这个方法已经实现了,子类尽量不要覆写。类间依赖的是抽象,覆写了抽象方法,对依赖的稳定性会产生一定的影响。

    • 结合里氏替换原则使用

         在上一个章节中我们讲解了里氏替换原则,父类出现的地方子类就能出现,再结合本章节的讲解,我们可以得出这样一个通俗的规则: 接口负责定义public属性和方法,并且声明与其他对象的依赖关系,抽象类负责公共构造部分的实现,实现类准确的实现业务逻辑,同时在适当的时候对父类进行细化。

         讲了这么多,估计大家对“倒置”这个词还是有点不理解,那到底什么是“倒置”呢?我们先说“正置”是什么意思,依赖正置就是类间的依赖是实实在在的实现类间的依赖,也就是面向实现编程,这也是正常人的思维方式,我要开奔驰车就依赖奔驰车,我要使用笔记本电脑就直接依赖笔记本电脑,而编写程序需要的是对现实世界的事物进行抽象,抽象的结果就是有了抽象类和接口,然后我们根据系统设计的需要产生了抽象间的依赖,代替了人们传统思维中的事物间的依赖,“倒置”就是从这里产生的。

         依赖倒置原则的优点在小型项目中很难体现出来,例如小于10个人月的项目,使用简单的SSH架构,基本上不费太大力气就可以完成,是否采用依赖倒置原则影响不大。但是,在一个大中型项目中,采用依赖倒置原则可以带来非常多的优点,特别是规避一些非技术因素引起的问题。项目越大,需求变化的概率也越大,通过采用依赖倒置原则设计的接口或抽象类对实现类进行约束,可以减少需求变化引起的工作量剧增的情况。人员的变动在大中型项目中也是时常存在的,如果设计优良、代码结构清晰,人员变化对项目的影响基本为零。大中型项目的维护周期一般都很长,采用依赖倒置原则可以让维护人员轻松地扩展和维护。

         依赖倒置原则是六个设计原则中最难以实现的原则,它是实现开闭原则的重要途径,依赖倒置原则没有实现,就别想实现对扩展开放,对修改关闭。在项目中,大家只要记住是“面向接口编程”就基本上抓住了依赖倒转原则的核心。

         讲了这么多依赖倒置原则的优点,我们也来打击一下大家,在现实世界中确实存在着必须依赖细节的事物,比如法律,就必须依赖细节的定义。 “杀人偿命”在中国的法律中古今有之,那这里的杀人就是一个抽象的含义,怎么杀,杀什么人,为什么杀人,都没有定义,只要是杀人就统统得偿命,那这就是有问题了,好人杀了坏人,还要陪上自己的一条性命,这是不公正的,从这一点看,我们在实际的项目中使用依赖倒置原则时需要审时度势,不要抓住一个原则不放,每一个原则的优点都是有限度的,并不是放之四海而皆准的真理,所以别为了遵循一个原则而放弃了一个项目的终极目标:投产上线和盈利。作为一个项目经理或架构师,应该懂得技术只是实现目的的工具,惹恼了顶头上司,设计做得再漂亮,代码写得再完美,项目做得再符合标准,一旦项目亏本,产品投入大于产出,那整体就是扯淡!你自己也别想混得更好!

  • 相关阅读:
    gThumb 3.1.2 发布,支持 WebP 图像
    航空例行天气预报解析 metaf2xml
    Baruwa 1.1.2 发布,邮件监控系统
    Bisect 1.3 发布,Caml 代码覆盖测试
    MoonScript 0.2.2 发布,基于 Lua 的脚本语言
    Varnish 入门
    快速增量备份程序 DeltaCopy
    恢复模糊的图像 SmartDeblur
    Cairo 1.12.8 发布,向量图形会图库
    iText 5.3.4 发布,Java 的 PDF 开发包
  • 原文地址:https://www.cnblogs.com/virusolf/p/5764207.html
Copyright © 2011-2022 走看看