06.里氏替换原则（Liskov Substitution Principle,LSP）

1.定义

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

• 定义看上去还是比较抽象，我们重新理解一下，可以理解为一个软件实体如果适用一 个父类的话，那一定是适用于其子类，所有引用父类的地方必须能透明地使用其子类的 对象，子类对象能够替换父类对象，而程序逻辑不变。

• 根据这个理解，我们总结一下： 引申含义：子类可以扩展父类的功能，但不能改变父类原有的功能。

• 1、子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。

• 2、子类中可以增加自己特有的方法。

• 3、当子类的方法重载父类的方法时，方法的前置条件（即方法的输入/入参）要比父类 方法的输入参数更宽松。

• 4、当子类的方法实现父类的方法时（重写/重载或实现抽象方法），方法的后置条件（即 方法的输出/返回值）要比父类更严格或相等。

好比开闭原则的案例时候在获取打折后时重写覆盖了父类的 getPrice()方法，增加了一个获取原价的方法 getOriginPrice()，显然就违背了里氏替换原则。我们修改一下代码，不应该覆盖 getPrice()方法，增加 getDiscountPrice ()方法

2.优点

• 约束继承泛滥，开闭原则的一种体现。
• 加强程序的健壮性，同时变更时也可以做到非常好的兼容性，提高程序的维护性、扩 展性。降低需求变更时引入的风险。

3.案例

业务场景：用正方形、矩形和四边形的关系说明里氏替换原则

3.1 初始代码

• 长方形

/**
 * 长方形
 */
public class Rectangle {
    private long width;
    private long height;

    public long getWidth() {
        return width;
    }

    public void setWidth(long width) {
        this.width = width;
    }

    public long getHeight() {
        return height;
    }

    public void setHeight(long height) {
        this.height = height;
    }
}

• 正方形继承长方形，并修改继承的代码

/**
 * 正方形
 */
public class Square extends Rectangle{
    private long length;

    public long getLength() {
        return length;
    }

    public void setLength(long length) {
        this.length = length;
    }

    @Override
    public long getWidth() {
        return getLength();
    }

    @Override
    public void setWidth(long width) {
        setLength(width);
    }

    @Override
    public long getHeight() {
        return getLength();
    }

    @Override
    public void setHeight(long height) {
        setLength(height);
    }
}

• 测试，分别测试长方形和正方形

public class SimpleTest {

    public static void resize(Rectangle rectangle){
        while (rectangle.getWidth() >= rectangle.getHeight()){
            rectangle.setHeight(rectangle.getHeight() + 1);
            System.out.println("Width:" + rectangle.getWidth() +",Height" + rectangle.getHeight());
        }
        System.out.println("Resize End,Width:" + rectangle.getWidth() +",Height" + rectangle.getHeight());
    }

    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.setWidth(20);
        rectangle.setHeight(10);
        resize(rectangle);
//		  测试正方形
//        Square square = new Square();
//        square.setLength(10);
//        resize(square);
    }
}

• 结果
  
  

所以在这个情况下，正方形它是不能调用resize的方法的，这个已经破坏了里氏替换原则，因为用父类的长方形可以，但是用子类的正方形就不行了，就已经变了，程序的行为已经发生了变化。

3.2 优化

实际上，我们可以进行优化，因为正方形和长方形有个共同之处是四边形，但是在某些情况下，正方形和长方形是不能成为父子关系的，但他们都是属于四边形，所以我们可以做一个四边形的抽象

• 四边形抽象接口

/**
 * 四边形
 */
public interface QuadRangle {
    long getWidth();
    long getHeight();
}

• 长方形实现接口

/**
 * 长方形
 */
public class Rectangle implements QuadRangle{

    private long height;

    private long width;

    public long getHeight() {
        return height;
    }

    public void setHeight(long height) {
        this.height = height;
    }

    public long getWidth() {
        return width;
    }

    public void setWidth(long width) {
        this.width = width;
    }
}

• 正方形实现接口

/**
 * 正方形
 */
public class Square implements QuadRangle{

    private long length;

    public long getLength() {
        return length;
    }

    public void setLength(long length) {
        this.length = length;
    }

    @Override
    public long getWidth() {
        return getLength();
    }

    @Override
    public long getHeight() {
        return getLength();
    }
}

• 测试类
  
  

这时候我们可以发现直接用四边形是不可以的，因为四边形里面是没有setHeight的方法的，不允许我们改的，只有是长方形才是可以的，所以这时候正方形也是调用不了这个resize的方法的，这里就可以杜绝一种继承泛滥的情况发生，这就是一种里氏替换原则的体现