浅谈Liskov Substitution Principle (LSP)

1.定义：对于LSP有一种更加好理解的定义

Functions that use pointers or references to base classes must be able to useobjects of derived classes without knowing it.

即：所有引用基类的地方必须能透明地使用其子类的对象。只要有父类出现的地方，都可以用子类来替代，而且不会出现任何错误和异常。但是反过来则不行，有子类出现的地方，不能用其父类替代。

2.针对的问题：继承的缺点

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

②降低了代码的灵活性。因为继承时，父类会对子类有一种约束。

③增强了耦合性。当需要对父类的代码进行修改时，必须考虑到对子类产生的影响。有时修改了一点点代码都有可能需要对打断程序进行重构。

3.LSP的要求：行为子类型的一个特殊定义，称作强行为子类型化
①前置条件不能强化
②后置条件不能弱化
③不变量要保持
④子类型方法参数：逆变
⑤子类型方法返回值：协变

4.LSP在Java中：java用静态检测确保以下规则：
①子类型可以增加方法，但不可删
②子类型需要实现抽象类型中的所有未实现方法
③子类型中重写的方法必须有相同或子类型的返回值
④子类型中重写的方法必须使用同样类型的参数
⑤子类型中重写的方法不能抛出额外的异常

5.代码举例：

举例说明继承的风险，我们需要完成一个两数相减的功能，由类A来负责。

class A{
    public int func1(int a, int b){
        return a-b;
    }
}

public class Client{
    public static void main(String[] args){
        A a = new A();
        System.out.println("100-50="+a.func1(100, 50));
        System.out.println("100-80="+a.func1(100, 80));
    }
}

运行结果：

100-50=50
100-80=20

后来，我们需要增加一个新的功能：完成两数相加，然后再与100求和，由类B来负责。即类B需要完成两个功能：

两数相减。

两数相加，然后再加100。

由于类A已经实现了第一个功能，所以类B继承类A后，只需要再完成第二个功能就可以了，代码如下：

class B extends A{
    public int func1(int a, int b){
        return a+b;
    }

    public int func2(int a, int b){
        return func1(a,b)+100;
    }
}

public class Client{
    public static void main(String[] args){
        B b = new B();
        System.out.println("100-50="+b.func1(100, 50));
        System.out.println("100-80="+b.func1(100, 80));
        System.out.println("100+20+100="+b.func2(100, 20));
    }
}

类B完成后，运行结果：

100-50=150
100-80=180
100+20+100=220

我们发现原本运行正常的相减功能发生了错误。原因就是类B在给方法起名时无意中重写了父类的方法，造成所有运行相减功能的代码全部调用了类B重写后的方法，造成原本运行正常的功能出现了错误。在本例中，引用基类A完成的功能，换成子类B之后，发生了异常。在实际编程中，我们常常会通过重写父类的方法来完成新的功能，这样写起来虽然简单，但是整个继承体系的可复用性会比较差，特别是运用多态比较频繁时，程序运行出错的几率非常大。如果非要重写父类的方法，比较通用的做法是：原来的父类和子类都继承一个更通俗的基类，原有的继承关系去掉，采用依赖、聚合，组合等关系代替。

6.对LSP的理解说明：

通俗的来讲就是：子类可以扩展父类的功能，但不能改变父类原有的功能。它包含以下2层含义：

子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法；
子类中可以增加自己特有的方法。

在项目中所有使用子类的地方都可用父类替换，但在调用方法的时候，即呈现面向对象编程的多态性。