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

设计模式 前端之家
前端之家收集整理的这篇文章主要介绍了设计模式六大原则 - 里氏替换原则，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

我们都知道面向对象有三大特性：封装、继承、多态。所以我们在实际开发过程中，子类在继承父类后，根据多态的特性，可能是图一时方便，经常任意重写父类的方法，那么这种方式会大大增加代码出问题的几率。比如下面场景：类C实现了某项功能F1。现在需要对功能F1作修改扩展，将功能F1扩展为F，其中F由原有的功能F1和新功能F2组成。新功能F由类C的子类C1来完成，则子类C1在完成功能F的同时，有可能会导致类C的原功能F1发生故障。这时候里氏替换原则就闪亮登场了。

原文链接：http://tianweili.github.io/blog/2015/02/04/liskov-substitution-principle/

什么是里氏替换原则

前面说过的单一职责原则，从字面意思就很好理解，但是里氏替换原则就有点让人摸不着头脑。查过资料后发现原来这项原则最早是在1988年，由麻省理工学院一位姓里的女士（Liskov）提出来的。

英文缩写：LSP (Liskov Substitution Principle)。

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

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

更通俗的定义：子类可以扩展父类的功能，但不能改变父类原有的功能。

代码示例

     
     

      
      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
     
     
     
     

      
      //抽象父类电脑
     
     

     
     

      
      public 
      
      abstract 
      
      class Computer {
     
     

     
     
    
      
      public abstract void use();
     
     

     
     

      
      }
     
     

     
     
 
     
     

     
     

      
      class IBM extends Computer{
     
     

     
     
    
      
      @Override
     
     

     
     
    
      
      public void use() {
     
     

     
     

      
              System.out.println(
      
      "use IBM Computer.");
     
     

     
     

      
          }
     
     

     
     

      
      }
     
     

     
     
 
     
     

     
     

      
      class HP extends Computer{
     
     

     
     
    
      
      @Override
     
     

     
     
    
      
      public void use() {
     
     

     
     

      
              System.out.println(
      
      "use HP Computer.");
     
     

     
     

      
          }
     
     

     
     

      
      }
     
     

     
     
 
     
     

     
     

      
      public 
      
      class Client{
     
     

     
     
    
      
      public static void main(String[] args) {
     
     

     
     

      
              Computer ibm = 
      
      new IBM();
     
     

     
     

      
              Computer hp = 
      
      new HP();
      
      //引用基类的地方能透明地使用其子类的对象。
     
     

     
     
         
     
     

     
     

      
              ibm.use();
     
     

     
     

      
              hp.use();
     
     

     
     

      
          }
     
     

     
     

      
      }

四层含义

里氏替换原则包含以下4层含义：

子类可以实现父类的抽象方法，但是不能覆盖父类的非抽象方法

在我们做系统设计时，经常会设计接口或抽象类，然后由子类来实现抽象方法，这里使用的其实就是里氏替换原则。子类可以实现父类的抽象方法很好理解，事实上，子类也必须完全实现父类的抽象方法，哪怕写一个空方法，否则会编译报错。

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

在面向对象的设计思想中，继承这一特性为系统的设计带来了极大的便利性，但是由之而来的也潜在着一些风险。就像开篇所提到的那一场景一样，对于那种情况最好遵循里氏替换原则，类C1继承类C时，可以添加新方法完成新增功能，尽量不要重写父类C的方法。否则可能带来难以预料的风险，比如下面一个简单的例子还原开篇的场景：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 
     
     

      
      public 
      
      class C {
     
     

     
     
    
      
      public int func(int a,int b){
     
     

     
     
        
      
      return a+b;
     
     

     
     

      
          }
     
     

     
     

      
      }
     
     

     
     
 
     
     

     
     

      
      public 
      
      class C1 extends C{
     
     

     
     
    
      
      @Override
     
     

     
     
    
      
      public int func(int a,int b) {
     
     

     
     
        
      
      return a-b;
     
     

     
     

      
          }
     
     

     
     

      
      }
     
     

     
     
 
     
     

     
     

      
      public 
      
      class Client{
     
     

     
     
    
      
      public static void main(String[] args) {
     
     

     
     

      
              C c = 
      
      new C1();
     
     

     
     

      
              System.out.println(
      
      "2+1=" + c.func(
      
      2,1));
     
     

     
     

      
          }
     
     

     
     

      
      }

运行结果：2+1=1

上面的运行结果明显是错误的。类C1继承C，后来需要增加新功能，类C1并没有新写一个方法，而是直接重写了父类C的func方法，违背里氏替换原则，引用父类的地方并不能透明的使用子类的对象，导致运行结果出错。

子类中可以增加自己特有的方法

在继承父类属性和方法的同时，每个子类也都可以有自己的个性，在父类的基础上扩展自己的功能。前面其实已经提到，当功能扩展时，子类尽量不要重写父类的方法，而是另写一个方法，所以对上面的代码加以更改，使其符合里氏替换原则，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 
int b){
     
     
     
     
        
      
      return a+b;
     
     

     
     

      
          }
     
     

     
     

      
      }
     
     

     
     
 
     
     

     
     

      
      public 
      
      class C1 extends C{
     
     

     
     
    
      
      public int func2(int a,int b) {
     
     

     
     
        
      
      return a-b;
     
     

     
     

      
          }
     
     

     
     

      
      }
     
     

     
     
 
     
     

     
     

      
      public 
      
      class Client{
     
     

     
     
    
      
      public static void main(String[] args) {
     
     

     
     

      
              C1 c = 
      
      new C1();
     
     

     
     

      
              System.out.println(
      
      "2-1=" + c.func2(
      
      2,1));
     
     

     
     

      
          }
     
     

     
     

      
      }

运行结果：2-1=1

当子类覆盖或实现父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 
     
     

      
      import java.util.HashMap;
     
     

     
     

      
      public 
      
      class Father {
     
     

     
     
    
      
      public void func(HashMap m){
     
     

     
     

      
              System.out.println(
      
      "执行父类...");
     
     

     
     

      
          }
     
     

     
     

      
      }
     
     

     
     
 
     
     

     
     

      
      import java.util.Map;
     
     

     
     

      
      public 
      
      class Son extends Father{
     
     

     
     
    
      
      public void func(Map m){
      
      //方法的形参比父类的更宽松
     
     

     
     

      
              System.out.println(
      
      "执行子类...");
     
     

     
     

      
          }
     
     

     
     

      
      }
     
     

     
     
 
     
     

     
     

      
      import java.util.HashMap;
     
     

     
     

      
      public 
      
      class Client{
     
     

     
     
    
      
      public static void main(String[] args) {
     
     

     
     

      
              Father f = 
      
      new Son();
      
      //引用基类的地方能透明地使用其子类的对象。
     
     

     
     

      
              HashMap h = 
      
      new HashMap();
     
     

     
     

      
              f.func(h);
     
     

     
     

      
          }
     
     

     
     

      
      }

运行结果：执行父类…

注意Son类的func方法前面是不能加@Override注解的，因为否则会编译提示报错，因为这并不是重写（Override），而是重载（Overload），因为方法的输入参数不同。重写和重载的区别在Java面向对象详解一文中已作解释，此处不再赘述。

当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格

代码示例：

import java.util.Map;
public abstract class Father {
public abstract Map func();
}
import java.util.HashMap;
public class Son extends Father{
@Override
public HashMap func(){ //方法的返回值比父类的更严格
HashMap h = new HashMap();
h.put( "h","执行子类...");
return h;
}
}
public class Client{
public static void main(String[] args) {
Father f = new Son(); //引用基类的地方能透明地使用其子类的对象。
System.out.println(f.func());
}
}

执行结果：{h=执行子类…}

总结

继承作为面向对象三大特性之一，在给程序设计带来巨大便利的同时，也带来了一些弊端，它增加了对象之间的耦合性。因此在系统设计时，遵循里氏替换原则，尽量避免子类重写父类的方法，可以有效降低代码出错的可能性。

作者：李天炜

原文链接：http://tianweili.github.io/blog/2015/02/04/liskov-substitution-principle/

转载请注明作者及出处，谢谢。

猜你在找的设计模式相关文章

适配器模式-让不兼容的接口得以适配
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以相互合...
策略模式-定义一个算法族
策略模式定义了一系列算法族，并封装在类中，它们之间可以互相替换，此模式让算法的变化独...
设计模式之高质量代码
设计模式讲的是如何编写可扩展、可维护、可读的高质量代码，它是针对软件开发中经常遇到的...
模板方法模式-封装一套算法流程
模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中，使得子类可以在...
迭代器模式-统一集合的遍历方式
迭代器模式提供了一种方法，用于遍历集合对象中的元素，而又不暴露其内部的细节。
单例模式的五种实现方式及优缺点
单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。
组合模式-统一的处理个别对象与组合对象
组合模式可以将对象组合成树形结构来表示“整体-部分”的层次结构，使得客户可以用一致的方...
装饰者模式-动态的包装原有对象的行为
装饰者模式能够更灵活的，动态的给对象添加其它功能，而不需要修改任何现有的底层代码。
观察者模式-将消息通知给观察者
观察者模式（Observer Design Pattern）定义了对象之间的一对多依赖，当对象状态改变的时候...
代理模式-访问对象的代理而非其本身
代理模式为对象提供一个代理，来控制对该对象的访问。代理模式在不改变原始类代码的情况下...
算法设计模式多媒体技术正则表达式ElasticsearchFlinkHadoopIDE
受约束摘*day25Java常用类库置信lamda留存持续录入年后正则表达式303.17regularexpre匹多模适20130322基础理论pathmunge涵义reectok需要转义的特资源分享validationex简明魔法里弄形如源码实现完备actionscript