设计模式原则：里氏替换原则（Liskov Substitution Principle, LSP）

定义

LSP由Barbara Liskov于1987年提出，一般有两种定义方式：

第一种：If for each object O1 of type S there is an object O2 fo type T such that for all programs P defined in terms of T, the behavior of P is unchanged when O1 is substitueted for O2 then S is a subtype of T. （对于每一个S类型的对象O1，都有一个T类型的对象O2，使以T定义的程序P在使用O2替换O1时，行为不发生变化，则S是T的子类）。

第二种：Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it. (所有引用基类的地方都必须能够使用子类对象，而且使用者不用知道任何差异，不必自己进行任何修改）。

通俗地讲，就是只要能使用父类对象的地方，就可以使用子类对象，并且这样的替换不会给程序带来任何错误或异常，这是满足“里氏替换原则”的继承。（注意顺序，父类可以用子类来替换，但是子类不一定能被父类替换）

举例

下面用一个例子来说明里氏替换原则（父类可以用子类来替换）：

我们需要完成一个两数相减的功能，由类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需要完成两个功能：

1. 两数相减。
2. 两数相加，然后再加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重写了A中的func1方法，造成了引用基类A完成的功能，换了子类B之后，发生了异常。那么这就是不符合“里氏替换原则”的继承。

如果非要重写父类的方法，比较通用的做法是：原来的父类和子类都继承一个更通俗的基类，原有的继承关系去掉，采用依赖、聚合，组合等关系代替。

里氏替换原则可以增强程序的健壮性，版本升级也可以具有很好的兼容性，即使增加子类，原有的子类还是可以继续运行。

含义

LSP包含以下四层含义：

1. 子类完全拥有父类的方法，且具体子类必须实现父类的抽象方法
2. 子类中可以增加自己的方法
3. 当子类覆盖或实现父类的方法时，方法的形参要比父类方法的更为宽松
   先明白两个概念，覆写和重载，覆写是指方法名和传入参数完全相同，重载是指方法名相同，但传入参数不同。看一个例子：
   父类：

public class Father {
    public Collection doSomething(HashMap hashMap){
        System.out.println("父类被执行。。。");
        return hashMap.values();
    }
}

子类：

public class Son extends Father {
    //子类重载父类方法，放大参数范围
    public Collection doSomething(Map map) {
        System.out.println("子类被执行。。。");
        return map.values();
    }
}

场景类：

public class Client {
    public static void invoker() {
        Father father = new Father();
        HashMap hashMap = new HashMap();
        father.doSomething(hashMap);
    }
    public static void main(String[] args) {
        invoker();
    }
}

运行结果：父类被执行。。。

根据里氏替换原则，如果替换父类为子类，即

Son son = new Son();
HashMap hashMap = new HashMap();
son.doSomething(hashMap);

运行的结果：父类被执行。。。

这个结果是正确的，子类的参数范围被放大后，替换父类所得的结果与调用父类的结果相同。但是，如果子类的参数范围小于父类的参数范围会怎样呢？

新父类：

public class Father {
    public Collection doSomething(Map map){
        System.out.println("父类被执行。。。");
        return map.values();
    }
}

新子类：

public class Son extends Father {
    //子类重载父类方法，放大参数范围
    public Collection doSomething(HashMap hashMap) {
        System.out.println("子类被执行。。。");
        return hashMap.values();
    }
}

新场景类

public class Client {
    public static void invoker() {
        Father father = new Father();
        HashMap hashMap = new HashMap();
        father.doSomething(hashMap);
    }
    public static void main(String[] args) {
        invoker();
    }
}

运行结果：父类被执行。。。

用子类替换父类：

Son son = new Son();
HashMap hashMap = new HashMap();
son.doSomething(hashMap);

运行结果：子类被执行。。。

运行结果出现了错误！子类在没有覆写父类方法的前提下，被执行了，这就会带来逻辑混乱，所以，子类方法中的前置条件必须与父类相同或比父类宽松。
4. 当子类覆盖或实现父类的方法时，方法的返回值要比父类更严格

看上去很不可思议，因为我们会发现在自己编程中常常会违反里氏替换原则，程序照样跑的好好的。所以大家都会产生这样的疑问，假如我非要不遵循里氏替换原则会有什么后果？
后果就是：你写的代码出问题的几率将会大大增加。

参考文章：
http://blog.csdn.net/zhengzhb/article/details/7281833
https://www.2cto.com/kf/201605/506949.html