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