设计模式—里氏替换原则

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.缺点

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

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

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