设计模式—里氏替换原则

1.概念

里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

通俗的讲：

1.所有引用基类的地方必须能透明的使用其子类的对象。其父类可以替换成子类，而子类不能替换成父类；

2.子类可以扩展父类的功能，但不能改变父类原有的功能；

2.举例

例如：鸟一般都会飞行，如燕子的飞行速度大概是每小时 120 千米。但是新西兰的几维鸟由于翅膀退化无法飞行。假如要设计一个实例，计算这两种鸟飞行 300 千米要花费的时间。显然，拿燕子来测试这段代码，结果正确，能计算出所需要的时间；但拿几维鸟来测试，结果会发生“除零异常”或是“无穷大”，明显不符合预期，类图如下：

未遵守里氏替换原则：

package com.example.demo.principle;public class LSPtest {public static void main(String[] args) {Bird bird1 = new Swallow();Bird bird2 = new BrownKiwi();bird1.setSpeed(120);bird2.setSpeed(120);System.out.println("如果飞行300公里：");try {System.out.println("燕子将飞行" + bird1.getFlyTime(300) + "小时.");System.out.println("几维鸟将飞行" + bird2.getFlyTime(300) + "小时。");} catch (Exception err) {System.out.println("发生错误了!");}}
}//鸟类
class Bird {double flySpeed;public void setSpeed(double speed) {flySpeed = speed;}public double getFlyTime(double distance) {return (distance / flySpeed);}
}//燕子类
class Swallow extends Bird {
}//几维鸟类
class BrownKiwi extends Bird {public void setSpeed(double speed) {flySpeed = 0;}}------------------   运行结果   --------------------------如果飞行300公里：
燕子将飞行2.5小时.
几维鸟将飞行Infinity小时。Process finished with exit code 0

这个设计存在的问题：

• 几维鸟类重写了鸟类的 setSpeed(double speed) 方法，这违背了里氏替换原则。

• 燕子和几维鸟都是鸟类，但是父类抽取的共性有问题，几维鸟的的飞行不是正常鸟类的功能，需要特殊处理，应该抽取更加共性的功能。

遵守里氏替换原则

优化：

取消几维鸟原来的继承关系，定义鸟和几维鸟的更一般的父类，如动物类，它们都有奔跑的能力。几维鸟的飞行速度虽然为 0，但奔跑速度不为 0，可以计算出其奔跑 300 千米所要花费的时间。

package com.example.demo.principle;public class Lsptest2 {public static void main(String[] args) {Animal animal1 = new Bird();Animal animal2 = new BrownKiwi();animal1.setRunSpeed(120);animal2.setRunSpeed(180);System.out.println("如果奔跑300公里：");try {System.out.println("鸟类将奔跑" + animal1.getRunSpeed(300) + "小时.");System.out.println("几维鸟将奔跑" + animal2.getRunSpeed(300) + "小时。");Bird bird = new Swallow();bird.setFlySpeed(150);System.out.println("如果飞行300公里：");System.out.println("燕子将飞行" + bird.getFlyTime(300) + "小时.");} catch (Exception err) {System.out.println("发生错误了!");}}
}/*** 动物类，抽象的功能更加具有共性*/class  Animal{Double runSpeed;public void setRunSpeed(double runSpeed) {this.runSpeed = runSpeed;}public double getRunSpeed(double distince) {return distince/runSpeed;}}/*** 鸟类继承动物类*/class Bird extends Animal{double flySpeed;public void setFlySpeed(double flySpeed) {this.flySpeed = flySpeed;}public double getFlyTime(double distince) {return distince/flySpeed;}}/*** 几维鸟继承动物类*/class  BrownKiwi extends  Animal{}/*** 燕子继承鸟类  飞行属于燕子的特性，*/class Swallow extends  Bird{}---------   运行结果  -----------------
如果奔跑300公里：
鸟类将奔跑2.5小时.
几维鸟将奔跑1.6666666666666667小时。
如果飞行300公里：
燕子将飞行2.0小时.

3.优点

• 代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性；

• 提高代码的重用性；

• 提高代码的可扩展性；

• 提高产品或项目的开放性；

4.缺点

• 继承是侵入性的。只要继承，就必须拥有父类的所有属性和方法；

• 降低代码的灵活性。子类必须拥有父类的属性和方法，让子类自由的世界中多了些约束；

• 增强了耦合性。当父类的常量、变量和方法被修改时，需要考虑子类的修改，而且在缺乏规范的环境下，这种修改可能带来非常糟糕的结果————大段的代码需要重构。