码迷,mamicode.com
首页 > 其他好文 > 详细

面向对象设计原则

时间:2015-09-24 16:07:32      阅读:284      评论:0      收藏:0      [点我收藏+]

标签:

转自周天令:http://note.youdao.com/share/web/file.html?id=8649b7356868c46650a932283501112e&type=note

 

1.单一职责原则

 
 
2.开放 封闭原则
 
3.里氏替换原则
 
4.依赖倒置原则
 
5.迪米特原则
 
6.接口隔离原则
 
 

 

面向对象设计原则之:单一职责原则

 

 
定义:不要存在多于一个导致类变更的原因。通俗的说,即一个类只负责一项职责。

问题由来:类T负责两个不同的职责:职责P1,职责P2。当由于职责P1需求发生改变而需要修改类T时,有可能会导致原本运行正常的职责P2功能发生故障。

解决方案:遵循单一职责原则。分别建立两个类T1、T2,使T1完成职责P1功能,T2完成职责P2功能。这样,当修改类T1时,不会使职责P2发生故障风险;同理,当修改T2时,也不会使职责P1发生故障风险。

         说到单一职责原则,很多人都会不屑一顾。因为它太简单了。稍有经验的程序员即使从来没有读过设计模式、从来没有听说过单一职责原则,在设计软件时也会自觉的遵守这一重要原则,因为这是常识。在软件编程中,谁也不希望因为修改了一个功能导致其他的功能发生故障。而避免出现这一问题的方法便是遵循单一职责原则。虽然单一职责原则如此简单,并且被认为是常识,但是即便是经验丰富的程序员写出的程序,也会有违背这一原则的代码存在。为什么会出现这种现象呢?因为有职责扩散。所谓职责扩散,就是因为某种原因,职责P被分化为粒度更细的职责P1和P2。

         比如:类T只负责一个职责P,这样设计是符合单一职责原则的。后来由于某种原因,也许是需求变更了,也许是程序的设计者境界提高了,需要将职责P细分为粒度更细的职责P1,P2,这时如果要使程序遵循单一职责原则,需要将类T也分解为两个类T1和T2,分别负责P1、P2两个职责。但是在程序已经写好的情况下,这样做简直太费时间了。所以,简单的修改类T,用它来负责两个职责是一个比较不错的选择,虽然这样做有悖于单一职责原则。(这样做的风险在于职责扩散的不确定性,因为我们不会想到这个职责P,在未来可能会扩散为P1,P2,P3,P4……Pn。所以记住,在职责扩散到我们无法控制的程度之前,立刻对代码进行重构。)

举例说明,用一个类描述动物呼吸这个场景:

  1. class Animal{  
  2.     public void breathe(String animal){  
  3.         System.out.println(animal+"呼吸空气");  
  4.     }  
  5. }  
  6. public class Client{  
  7.     public static void main(String[] args){  
  8.         Animal animal = new Animal();  
  9.         animal.breathe("牛");  
  10.         animal.breathe("羊");  
  11.         animal.breathe("猪");  
  12.     }  
  13. }  

运行结果:

牛呼吸空气
羊呼吸空气
猪呼吸空气

        程序上线后,发现问题了,并不是所有的动物都呼吸空气的,比如鱼就是呼吸水的。修改时如果遵循单一职责原则,需要将Animal类细分为陆生动物类Terrestrial,水生动物Aquatic,代码如下:

  1. class Terrestrial{  
  2.     public void breathe(String animal){  
  3.         System.out.println(animal+"呼吸空气");  
  4.     }  
  5. }  
  6. class Aquatic{  
  7.     public void breathe(String animal){  
  8.         System.out.println(animal+"呼吸水");  
  9.     }  
  10. }  
  11.   
  12. public class Client{  
  13.     public static void main(String[] args){  
  14.         Terrestrial terrestrial = new Terrestrial();  
  15.         terrestrial.breathe("牛");  
  16.         terrestrial.breathe("羊");  
  17.         terrestrial.breathe("猪");  
  18.           
  19.         Aquatic aquatic = new Aquatic();  
  20.         aquatic.breathe("鱼");  
  21.     }  
  22. }  


运行结果:

牛呼吸空气
羊呼吸空气
猪呼吸空气
鱼呼吸水

我们会发现如果这样修改花销是很大的,除了将原来的类分解之外,还需要修改客户端。而直接修改类Animal来达成目的虽然违背了单一职责原则,但花销却小的多,代码如下:

  1. class Animal{  
  2.     public void breathe(String animal){  
  3.         if("鱼".equals(animal)){  
  4.             System.out.println(animal+"呼吸水");  
  5.         }else{  
  6.             System.out.println(animal+"呼吸空气");  
  7.         }  
  8.     }  
  9. }  
  10.   
  11. public class Client{  
  12.     public static void main(String[] args){  
  13.         Animal animal = new Animal();  
  14.         animal.breathe("牛");  
  15.         animal.breathe("羊");  
  16.         animal.breathe("猪");  
  17.         animal.breathe("鱼");  
  18.     }  
  19. }  


        可以看到,这种修改方式要简单的多。但是却存在着隐患:有一天需要将鱼分为呼吸淡水的鱼和呼吸海水的鱼,则又需要修改Animal类的breathe方法,而对原有代码的修改会对调用“猪”“牛”“羊”等相关功能带来风险,也许某一天你会发现程序运行的结果变为“牛呼吸水”了。这种修改方式直接在代码级别上违背了单一职责原则,虽然修改起来最简单,但隐患却是最大的。还有一种修改方式:

  1. class Animal{  
  2.     public void breathe(String animal){  
  3.         System.out.println(animal+"呼吸空气");  
  4.     }  
  5.   
  6.     public void breathe2(String animal){  
  7.         System.out.println(animal+"呼吸水");  
  8.     }  
  9. }  
  10.   
  11. public class Client{  
  12.     public static void main(String[] args){  
  13.         Animal animal = new Animal();  
  14.         animal.breathe("牛");  
  15.         animal.breathe("羊");  
  16.         animal.breathe("猪");  
  17.         animal.breathe2("鱼");  
  18.     }  
  19. }  


        可以看到,这种修改方式没有改动原来的方法,而是在类中新加了一个方法,这样虽然也违背了单一职责原则,但在方法级别上却是符合单一职责原则的,因为它并没有动原来方法的代码。这三种方式各有优缺点,那么在实际编程中,采用哪一中呢?其实这真的比较难说,需要根据实际情况来确定。我的原则是:只有逻辑足够简单,才可以在代码级别上违反单一职责原则;只有类中方法数量足够少,才可以在方法级别上违反单一职责原则;

        例如本文所举的这个例子,它太简单了,它只有一个方法,所以,无论是在代码级别上违反单一职责原则,还是在方法级别上违反,都不会造成太大的影响。实际应用中的类都要复杂的多,一旦发生职责扩散而需要修改类时,除非这个类本身非常简单,否则还是遵循单一职责原则的好。

遵循单一职责原的优点有:

  • 可以降低类的复杂度,一个类只负责一项职责,其逻辑肯定要比负责多项职责简单的多;
  • 提高类的可读性,提高系统的可维护性;
  • 变更引起的风险降低,变更是必然的,如果单一职责原则遵守的好,当修改一个功能时,可以显著降低对其他功能的影响。

        需要说明的一点是单一职责原则不只是面向对象编程思想所特有的,只要是模块化的程序设计,都适用单一职责原则。

面向对象设计原则之:开放封闭原则

 

开发封闭原则(Open-Closed Principle OCP)

Software entities(classes,modules,functions etc) should open for extension ,but close for modification.

   什么意思呢?

   所谓开放封闭原则就是软件实体应该对扩展开发,而对修改封闭。开放封闭原则是所有面向对象原则的核心。软件设计本身所追求的目标就是封装变化,降低耦合,而开放封闭原则正是对这一目标的最直接体现。

   开放封闭原则主要体现在两个方面:

   对扩展开放,意味着有新的需求或变化时,可以对现有代码进行扩展,以适应新的情况。

   对修改封闭,意味着类一旦设计完成,就可以独立其工作,而不要对类尽任何修改。

 

为什么要用到开放封闭原则呢?

软件需求总是变化的,世界上没有一个软件的是不变的,因此对软件设计人员来说,必须在不需要对原有系统进行修改的情况下,实现灵活的系统扩展。

 

如何做到对扩展开放,对修改封闭呢?

      实现开放封闭的核心思想就是对抽象编程,而不对具体编程,因为抽象相对稳定。让类依赖于固定的抽象,所以对修改就是封闭的;而通过面向对象的继承和多态机制,可以实现对抽象体的继承,通过覆写其方法来改变固有行为,实现新的扩展方法,所以对于扩展就是开放的。

      对于违反这一原则的类,必须通过重构来进行改善。常用于实现的设计模式主要有Template Method模式和Strategy 模式。而封装变化,是实现这一原则的重要手段,将经常变化的状态封装为一个类。

以银行业务员为例

没有实现OCP的设计:

public class BankProcess

    {  //存款 

       public void Deposite(){}

        //取款

        public void Withdraw(){ }

        //转账

        public void Transfer(){}

    }

    public class BankStaff

    {

        private BankProcess bankpro = new BankProcess();

        public void BankHandle(Client client)

        {

            switch (client.Type)

            {  //存款

                case "deposite":

                    bankpro.Deposite();

                    break;

                    //取款

                case "withdraw":

                    bankpro.Withdraw();

                    break;

                    //转账

                case "transfer":

                    bankpro.Transfer();

                    break;

            }

        }

    }

     这种设计显然是存在问题的,目前设计中就只有存款,取款和转账三个功能,将来如果业务增加了,比如增加申购基金功能,理财功能等,就必须要修改BankProcess业务类。我们分析上述设计就不能发现把不能业务封装在一个类里面,违反单一职责原则,而有新的需求发生,必须修改现有代码则违反了开放封闭原则。

      从开放封闭的角度来分析,在银行系统中最可能扩展的就是业务功能的增加或变更。对业务流程应该作为扩展的部分来实现。当有新的功能时,不需要再对现有业务进行重新梳理,然后再对系统做大的修改。

如何才能实现耦合度和灵活性兼得呢?

那就是抽象,将业务功能抽象为接口,当业务员依赖于固定的抽象时,对修改就是封闭的,而通过继承和多态继承,从抽象体中扩展出新的实现,就是对扩展的开放。

以下是符合OCP的设计:

首先声明一个业务处理接口

public  interface IBankProcess{  void Process();}

public class DepositProcess : IBankProcess

    {

        public void Process()

        { //办理存款业务

            Console.WriteLine("Process Deposit");

        }

}

public class WithDrawProcess : IBankProcess

    {

        public void Process()

        { //办理取款业务

            Console.WriteLine("Process WithDraw");

        }

}

public class TransferProcess : IBankProcess

    {

        public void Process()

        { //办理转账业务

            Console.WriteLine("Process Transfer");

        }

    }

public class BankStaff

    {

        private IBankProcess bankpro = null;

        public void BankHandle(Client client)

        {

            switch (client.Type)

            {   //存款

                case "Deposit":

                    userProc = new DepositUser();

                    break;

                    //转账

                case "Transfer":

                    userProc = new TransferUser();

                    break;

                    //取款

                case "WithDraw":

                    userProc = new WithDrawUser();

                    break;

            }

            userProc.Process();

        }

    }

 

这样当业务变更时,只需要修改对应的业务实现类就可以,其他不相干的业务就不必修改。当业务增加,只需要增加业务的实现就可以了。

 

设计建议:

开放封闭原则,是最为重要的设计原则,Liskov替换原则和合成/聚合复用原则为开放封闭原则提供保证。

可以通过Template Method模式和Strategy模式进行重构,实现对修改封闭,对扩展开放的设计思路。

封装变化,是实现开放封闭原则的重要手段,对于经常发生变化的状态,一般将其封装为一个抽象,例如银行业务中IBankProcess接口。

拒绝滥用抽象,只将经常变化的部分进行抽象。

 

 

 

 设计模式六大原则之:里氏替换原则

 

 

 肯定有不少人跟我刚看到这项原则的时候一样,对这个原则的名字充满疑惑。其实原因就是这项原则最早是在1988年,由麻省理工学院的一位姓里的女士(Barbara Liskov)提出来的。

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

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

问题由来:有一功能P1,由类A完成。现需要将功能P1进行扩展,扩展后的功能为P,其中P由原有功能P1与新功能P2组成。新功能P由类A的子类B来完成,则子类B在完成新功能P2的同时,有可能会导致原有功能P1发生故障。

解决方案:当使用继承时,遵循里氏替换原则。类B继承类A时,除添加新的方法完成新增功能P2外,尽量不要重写父类A的方法,也尽量不要重载父类A的方法。

         继承包含这样一层含义:父类中凡是已经实现好的方法(相对于抽象方法而言),实际上是在设定一系列的规范和契约,虽然它不强制要求所有的子类必须遵从这些契约,但是如果子类对这些非抽象方法任意修改,就会对整个继承体系造成破坏。而里氏替换原则就是表达了这一层含义。

        继承作为面向对象三大特性之一,在给程序设计带来巨大便利的同时,也带来了弊端。比如使用继承会给程序带来侵入性,程序的可移植性降低,增加了对象间的耦合性,如果一个类被其他的类所继承,则当这个类需要修改时,必须考虑到所有的子类,并且父类修改后,所有涉及到子类的功能都有可能会产生故障。

        举例说明继承的风险,我们需要完成一个两数相减的功能,由类A来负责。

  1. class A{  
  2.     public int func1(int a, int b){  
  3.         return a-b;  
  4.     }  
  5. }  
  6.   
  7. public class Client{  
  8.     public static void main(String[] args){  
  9.         A a = new A();  
  10.         System.out.println("100-50="+a.func1(100, 50));  
  11.         System.out.println("100-80="+a.func1(100, 80));  
  12.     }  
  13. }  


 运行结果:

100-50=50
100-80=20

        后来,我们需要增加一个新的功能:完成两数相加,然后再与100求和,由类B来负责。即类B需要完成两个功能:

  • 两数相减。
  • 两数相加,然后再加100。

        由于类A已经实现了第一个功能,所以类B继承类A后,只需要再完成第二个功能就可以了,代码如下:

  1. class B extends A{  
  2.     public int func1(int a, int b){  
  3.         return a+b;  
  4.     }  
  5.       
  6.     public int func2(int a, int b){  
  7.         return func1(a,b)+100;  
  8.     }  
  9. }  
  10.   
  11. public class Client{  
  12.     public static void main(String[] args){  
  13.         B b = new B();  
  14.         System.out.println("100-50="+b.func1(100, 50));  
  15.         System.out.println("100-80="+b.func1(100, 80));  
  16.         System.out.println("100+20+100="+b.func2(100, 20));  
  17.     }  
  18. }  

类B完成后,运行结果:

100-50=150
100-80=180
100+20+100=220

        我们发现原本运行正常的相减功能发生了错误。原因就是类B在给方法起名时无意中重写了父类的方法,造成所有运行相减功能的代码全部调用了类B重写后的方法,造成原本运行正常的功能出现了错误。在本例中,引用基类A完成的功能,换成子类B之后,发生了异常。在实际编程中,我们常常会通过重写父类的方法来完成新的功能,这样写起来虽然简单,但是整个继承体系的可复用性会比较差,特别是运用多态比较频繁时,程序运行出错的几率非常大。如果非要重写父类的方法,比较通用的做法是:原来的父类和子类都继承一个更通俗的基类,原有的继承关系去掉,采用依赖、聚合,组合等关系代替。

        里氏替换原则通俗的来讲就是:子类可以扩展父类的功能,但不能改变父类原有的功能。它包含以下4层含义:

  • 子类可以实现父类的抽象方法,但不能覆盖父类的非抽象方法。
  • 子类中可以增加自己特有的方法。
  • 当子类的方法重载父类的方法时,方法的前置条件(即方法的形参)要比父类方法的输入参数更宽松。
  • 当子类的方法实现父类的抽象方法时,方法的后置条件(即方法的返回值)要比父类更严格。

        看上去很不可思议,因为我们会发现在自己编程中常常会违反里氏替换原则,程序照样跑的好好的。所以大家都会产生这样的疑问,假如我非要不遵循里氏替换原则会有什么后果?

        后果就是:你写的代码出问题的几率将会大大增加。

 

 

 

设计模式六大原则之:依赖倒置原则

 

定义:高层模块不应该依赖低层模块,二者都应该依赖其抽象;抽象不应该依赖细节;细节应该依赖抽象。

问题由来:类A直接依赖类B,假如要将类A改为依赖类C,则必须通过修改类A的代码来达成。这种场景下,类A一般是高层模块,负责复杂的业务逻辑;类B和类C是低层模块,负责基本的原子操作;假如修改类A,会给程序带来不必要的风险。

解决方案:将类A修改为依赖接口I,类B和类C各自实现接口I,类A通过接口I间接与类B或者类C发生联系,则会大大降低修改类A的几率。

         依赖倒置原则基于这样一个事实:相对于细节的多变性,抽象的东西要稳定的多。以抽象为基础搭建起来的架构比以细节为基础搭建起来的架构要稳定的多。在java中,抽象指的是接口或者抽象类,细节就是具体的实现类,使用接口或者抽象类的目的是制定好规范和契约,而不去涉及任何具体的操作,把展现细节的任务交给他们的实现类去完成。

         依赖倒置原则的核心思想是面向接口编程,我们依旧用一个例子来说明面向接口编程比相对于面向实现编程好在什么地方。场景是这样的,母亲给孩子讲故事,只要给她一本书,她就可以照着书给孩子讲故事了。代码如下:

  1. class Book{  
  2.     public String getContent(){  
  3.         return "很久很久以前有一个阿拉伯的故事……";  
  4.     }  
  5. }  
  6.   
  7. class Mother{  
  8.     public void narrate(Book book){  
  9.         System.out.println("妈妈开始讲故事");  
  10.         System.out.println(book.getContent());  
  11.     }  
  12. }  
  13.   
  14. public class Client{  
  15.     public static void main(String[] args){  
  16.         Mother mother = new Mother();  
  17.         mother.narrate(new Book());  
  18.     }  
  19. }  

运行结果:

妈妈开始讲故事
很久很久以前有一个阿拉伯的故事……

        运行良好,假如有一天,需求变成这样:不是给书而是给一份报纸,让这位母亲讲一下报纸上的故事,报纸的代码如下:

  1. class Newspaper{  
  2.     public String getContent(){  
  3.         return "林书豪38+7领导尼克斯击败湖人……";  
  4.     }  
  5. }  

        这位母亲却办不到,因为她居然不会读报纸上的故事,这太荒唐了,只是将书换成报纸,居然必须要修改Mother才能读。假如以后需求换成杂志呢?换成网页呢?还要不断地修改Mother,这显然不是好的设计。原因就是Mother与Book之间的耦合性太高了,必须降低他们之间的耦合度才行。

我们引入一个抽象的接口IReader。读物,只要是带字的都属于读物:

  1. interface IReader{  
  2.     public String getContent();  
  3. }  

Mother类与接口IReader发生依赖关系,而Book和Newspaper都属于读物的范畴,他们各自都去实现IReader接口,这样就符合依赖倒置原则了,代码修改为:

  1. class Newspaper implements IReader {  
  2.     public String getContent(){  
  3.         return "林书豪17+9助尼克斯击败老鹰……";  
  4.     }  
  5. }  
  6. class Book implements IReader{  
  7.     public String getContent(){  
  8.         return "很久很久以前有一个阿拉伯的故事……";  
  9.     }  
  10. }  
  11.   
  12. class Mother{  
  13.     public void narrate(IReader reader){  
  14.         System.out.println("妈妈开始讲故事");  
  15.         System.out.println(reader.getContent());  
  16.     }  
  17. }  
  18.   
  19. public class Client{  
  20.     public static void main(String[] args){  
  21.         Mother mother = new Mother();  
  22.         mother.narrate(new Book());  
  23.         mother.narrate(new Newspaper());  
  24.     }  
  25. }  

运行结果:

妈妈开始讲故事
很久很久以前有一个阿拉伯的故事……
妈妈开始讲故事
林书豪17+9助尼克斯击败老鹰……

    这样修改后,无论以后怎样扩展Client类,都不需要再修改Mother类了。这只是一个简单的例子,实际情况中,代表高层模块的Mother类将负责完成主要的业务逻辑,一旦需要对它进行修改,引入错误的风险极大。所以遵循依赖倒置原则可以降低类之间的耦合性,提高系统的稳定性,降低修改程序造成的风险。

    采用依赖倒置原则给多人并行开发带来了极大的便利,比如上例中,原本Mother类与Book类直接耦合时,Mother类必须等Book类编码完成后才可以进行编码,因为Mother类依赖于Book类。修改后的程序则可以同时开工,互不影响,因为Mother与Book类一点关系也没有。参与协作开发的人越多、项目越庞大,采用依赖导致原则的意义就越重大。现在很流行的TDD开发模式就是依赖倒置原则最成功的应用。

         传递依赖关系有三种方式,以上的例子中使用的方法是接口传递,另外还有两种传递方式:构造方法传递setter方法传递,相信用过Spring框架的,对依赖的传递方式一定不会陌生。
在实际编程中,我们一般需要做到如下3点:

  • 低层模块尽量都要有抽象类或接口,或者两者都有。
  • 变量的声明类型尽量是抽象类或接口。
  • 使用继承时遵循里氏替换原则。

        依赖倒置原则的核心就是要我们面向接口编程,理解了面向接口编程,也就理解了依赖倒置。

 

 

 

 

 

设计模式之六大原则之:迪米特法则(LoD,LKP)
 

定义:

迪米特法则(Law of Demeter,LoD)也称为最少知识原则(Least Knowledge Principle,LKP)。

一个对象应该对其他对象有最少的了解。通俗地讲,一个类应该对自己需要耦合或调用的类知道得最少,你(被耦合或调用的类)的内部是如何复杂都和我没关系,那是你的事情,我就知道你提供的public方法,我就调用这么多,其他的一概不关心。

 

含义:

  • 只和朋友交流

朋友类的定义是这样的:出现在成员变量、方法的输入输出参数中的类称为成员朋友类,而出现在方法体内部的类不属于朋友类。

 

下面的代码在方法体内部依赖了其他类,这严重违反迪米特法则

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Teacher {
 
    public void commond(GroupLeader groupLeader) {
        List<Girl> listGirls = new ArrayList<Girl>();
 
        for (int i = 0; i < 20; i++) {
            listGirls.add(new Girl());
        }
 
        groupLeader.countGirls(listGirls);
    }
 
}

 

方法是类的一个行为,类竟然不知道自己的行为与其他类产生了依赖关系,这是不允许的。

正确的做法是:

1
2
3
4
5
6
7
public class Teacher {
 
    public void commond(GroupLeader groupLeader) {
        groupLeader.countGirls();
    }
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public class GroupLeader {
 
    private List<Girl> listGirls;
 
    public GroupLeader(List<Girl> _listGirls) {
        this.listGirls = _listGirls;
    }
 
    public void countGirls() {
        System.out.println("女生数量是:" + listGirls.size());
    }
 
}

注意:一个类只和朋友交流,不与陌生类交流,不要出现getA().getB().getC().getD()这种情况(在一种极端情况下允许出现这种访问,即每一个点号后面的返回类型都相同),类与类之间的关系是建立在类间的,而不是方法间,因此一个方法尽量不引入一个类中不存在的对象,当然,JDK API提供的类除外。

  • 朋友间也是有距离的

一个类公开的public属性或方法越多,修改时涉及的面也就越大,变更引起的风险扩散也就越大。因此,为了保持朋友类间的距离,在设计时需要反复衡量:是否还可以再减少public方法和属性,是否可以修改为private、package-private(包类型,在类、方法、变量前不加访问权限,则默认为包类型)、protected等访问权限,是否可以加上final关键字等。

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

 

  • 是自己的就是自己的

如果一个方法放在本类中,既不增加类间关系,也对本类不产生负面影响,就放置在本类中。

 

  • 谨慎使用Serializable

 

最后,迪米特法则的核心观念就是类间解耦,弱耦合,只有弱耦合了以后,类的复用率才可以提高。

 

 


 

设计模式六大原则之:接口隔离原则
 
定义:客户端不应该依赖它不需要的接口;一个类对另一个类的依赖应该建立在最小的接口上。

问题由来:类A通过接口I依赖类B,类C通过接口I依赖类D,如果接口I对于类A和类B来说不是最小接口,则类B和类D必须去实现他们不需要的方法。

解决方案:将臃肿的接口I拆分为独立的几个接口,类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则。

举例来说明接口隔离原则:

技术分享

(图1  未遵循接口隔离原则的设计)

         这个图的意思是:类A依赖接口I中的方法1、方法2、方法3,类B是对类A依赖的实现。类C依赖接口I中的方法1、方法4、方法5,类D是对类C依赖的实现。对于类B和类D来说,虽然他们都存在着用不到的方法(也就是图中红色字体标记的方法),但由于实现了接口I,所以也必须要实现这些用不到的方法。对类图不熟悉的可以参照程序代码来理解,代码如下:

  1. interface I {  
  2.     public void method1();  
  3.     public void method2();  
  4.     public void method3();  
  5.     public void method4();  
  6.     public void method5();  
  7. }  
  8.   
  9. class A{  
  10.     public void depend1(I i){  
  11.         i.method1();  
  12.     }  
  13.     public void depend2(I i){  
  14.         i.method2();  
  15.     }  
  16.     public void depend3(I i){  
  17.         i.method3();  
  18.     }  
  19. }  
  20.   
  21. class B implements I{  
  22.     public void method1() {  
  23.         System.out.println("类B实现接口I的方法1");  
  24.     }  
  25.     public void method2() {  
  26.         System.out.println("类B实现接口I的方法2");  
  27.     }  
  28.     public void method3() {  
  29.         System.out.println("类B实现接口I的方法3");  
  30.     }  
  31.     //对于类B来说,method4和method5不是必需的,但是由于接口A中有这两个方法,  
  32.     //所以在实现过程中即使这两个方法的方法体为空,也要将这两个没有作用的方法进行实现。  
  33.     public void method4() {}  
  34.     public void method5() {}  
  35. }  
  36.   
  37. class C{  
  38.     public void depend1(I i){  
  39.         i.method1();  
  40.     }  
  41.     public void depend2(I i){  
  42.         i.method4();  
  43.     }  
  44.     public void depend3(I i){  
  45.         i.method5();  
  46.     }  
  47. }  
  48.   
  49. class D implements I{  
  50.     public void method1() {  
  51.         System.out.println("类D实现接口I的方法1");  
  52.     }  
  53.     //对于类D来说,method2和method3不是必需的,但是由于接口A中有这两个方法,  
  54.     //所以在实现过程中即使这两个方法的方法体为空,也要将这两个没有作用的方法进行实现。  
  55.     public void method2() {}  
  56.     public void method3() {}  
  57.   
  58.     public void method4() {  
  59.         System.out.println("类D实现接口I的方法4");  
  60.     }  
  61.     public void method5() {  
  62.         System.out.println("类D实现接口I的方法5");  
  63.     }  
  64. }  
  65.   
  66. public class Client{  
  67.     public static void main(String[] args){  
  68.         A a = new A();  
  69.         a.depend1(new B());  
  70.         a.depend2(new B());  
  71.         a.depend3(new B());  
  72.           
  73.         C c = new C();  
  74.         c.depend1(new D());  
  75.         c.depend2(new D());  
  76.         c.depend3(new D());  
  77.     }  
  78. }  

        可以看到,如果接口过于臃肿,只要接口中出现的方法,不管对依赖于它的类有没有用处,实现类中都必须去实现这些方法,这显然不是好的设计。如果将这个设计修改为符合接口隔离原则,就必须对接口I进行拆分。在这里我们将原有的接口I拆分为三个接口,拆分后的设计如图2所示:

技术分享

 

(图2  遵循接口隔离原则的设计)

照例贴出程序的代码,供不熟悉类图的朋友参考:

  1. interface I1 {  
  2.     public void method1();  
  3. }  
  4.   
  5. interface I2 {  
  6.     public void method2();  
  7.     public void method3();  
  8. }  
  9.   
  10. interface I3 {  
  11.     public void method4();  
  12.     public void method5();  
  13. }  
  14.   
  15. class A{  
  16.     public void depend1(I1 i){  
  17.         i.method1();  
  18.     }  
  19.     public void depend2(I2 i){  
  20.         i.method2();  
  21.     }  
  22.     public void depend3(I2 i){  
  23.         i.method3();  
  24.     }  
  25. }  
  26.   
  27. class B implements I1, I2{  
  28.     public void method1() {  
  29.         System.out.println("类B实现接口I1的方法1");  
  30.     }  
  31.     public void method2() {  
  32.         System.out.println("类B实现接口I2的方法2");  
  33.     }  
  34.     public void method3() {  
  35.         System.out.println("类B实现接口I2的方法3");  
  36.     }  
  37. }  
  38.   
  39. class C{  
  40.     public void depend1(I1 i){  
  41.         i.method1();  
  42.     }  
  43.     public void depend2(I3 i){  
  44.         i.method4();  
  45.     }  
  46.     public void depend3(I3 i){  
  47.         i.method5();  
  48.     }  
  49. }  
  50.   
  51. class D implements I1, I3{  
  52.     public void method1() {  
  53.         System.out.println("类D实现接口I1的方法1");  
  54.     }  
  55.     public void method4() {  
  56.         System.out.println("类D实现接口I3的方法4");  
  57.     }  
  58.     public void method5() {  
  59.         System.out.println("类D实现接口I3的方法5");  
  60.     }  
  61. }  

        接口隔离原则的含义是:建立单一接口,不要建立庞大臃肿的接口,尽量细化接口,接口中的方法尽量少。也就是说,我们要为各个类建立专用的接口,而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。本文例子中,将一个庞大的接口变更为3个专用的接口所采用的就是接口隔离原则。在程序设计中,依赖几个专用的接口要比依赖一个综合的接口更灵活。接口是设计时对外部设定的“契约”,通过分散定义多个接口,可以预防外来变更的扩散,提高系统的灵活性和可维护性。

         说到这里,很多人会觉的接口隔离原则跟之前的单一职责原则很相似,其实不然。其一,单一职责原则原注重的是职责;而接口隔离原则注重对接口依赖的隔离。其二,单一职责原则主要是约束类,其次才是接口和方法,它针对的是程序中的实现和细节;而接口隔离原则主要约束接口接口,主要针对抽象,针对程序整体框架的构建。

         采用接口隔离原则对接口进行约束时,要注意以下几点:

  • 接口尽量小,但是要有限度。对接口进行细化可以提高程序设计灵活性是不挣的事实,但是如果过小,则会造成接口数量过多,使设计复杂化。所以一定要适度。
  • 为依赖接口的类定制服务,只暴露给调用的类它需要的方法,它不需要的方法则隐藏起来。只有专注地为一个模块提供定制服务,才能建立最小的依赖关系。
  • 提高内聚,减少对外交互。使接口用最少的方法去完成最多的事情。

运用接口隔离原则,一定要适度,接口设计的过大或过小都不好。设计接口的时候,只有多花些时间去思考和筹划,才能准确地实践这一原则。

面向对象设计原则

标签:

原文地址:http://www.cnblogs.com/daxiong2014/p/4835546.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!