如需下载源码，请访问
https://github.com/fengchuanfang/Liskov_Substitution_Principle
文章原创，转载请注明出处：
设计模式心法之里氏替换原则
里氏替换原则(Liskov Substitution Principle，LSP)
——设计模式基本原则之一
定义1
如果对每一个类型为S的对象O1，都有类型为T的对象O2，使得以T定义的所有程序P在所有的对象O1都替换成O2时，程序P的行为没有发生变化，那么类型S是类型T的子类型。（If for each object O1 of type S there is an object o2 of type T such that for all programs P defined in terms of T,the behavior of P is unchanged when O1 is substituted for O2 then S is a subtype of T.）
定义2
所有引用基类的地方必须能透明地使用其子类的对象（Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it.）
继承是面向对象语言的三大特点之一，也是面向对象语言的一大优势。使用继承可以使相关类间的层次结构关系更加清晰，提高代码的重用性和拓展性，但是滥用继承又会适得其反，不仅增加父子类之间的耦合性，而且父类的属性和方法对子类具有侵入性，还降低了子类代码的灵活性，如果更改父类的属性或方法，将会影响所有子类功能的运行。
里氏替换原则为我们能够良好的使用继承提供了一个规范，其核心如定义中所说：
任何使用基类的地方都可以在不了解其子类具体实现的情况下，无条件地使用其子类替换，而不会产生任何错误或异常。这要求子类可以拓展父类的功能，但不能改变父类原有的功能。包含以下4个方面：
一、子类必须实现父类的抽象方法，但是不能重写父类的非抽象方法。
在java语言中，如果子类继承父类，不实现父类的抽象方法，连编译都通过不了，前半句看起来好像是废话，但是这里的实现并不是简单的遵守java语法规则那么简单，它要求子类在继承父类时，子类必须遵守父类方法的约定，完全实现父类的方法，而不仅仅是为了编译通过的实现。
例如，有一用户信息抽象类如下：
public abstract class AUserInfo {
public String getTitle() {
return "用户信息";
}
// 返回值非空
public abstract String getName();
}
实现getTitle()的方法，留下getName()方法交给子类去实现。
有一用户信息展示工具类：
public class ShowUserInfo {
public static void showUserInfo(AUserInfo userInfo) {
System.out.println(userInfo.getTitle() + "\r\n姓名：" + userInfo.getName().trim());
}
}
UserInfo1为AUserInfo的子类，实现AUserInfo的抽象方法：
public class UserInfo1 extends AUserInfo {
@Override
public String getName() {
return "Edward";
}
}
在场景类中展示UserInfo1信息：
public class Client {
public static void main(String args[]) {
ShowUserInfo.showUserInfo(new UserInfo1());
}
}
运行之后，控制台打印信息如下：
用户信息
姓名：Edward
如果有一AUserInfo的子类UserInfo2在实现其抽象方法时，并没有完全遵照其方法的约定返回为null,代码如下：
public class UserInfo2 extends AUserInfo{
@Override
public String getName() {
return null;
}
}
通过场景类展示其信息：
public class Client {
public static void main(String args[]) {
ShowUserInfo.showUserInfo(new UserInfo2());
}
}
运行后，会发现程序运行报空指针异常
Exception in thread "main" java.lang.NullPointerException
at demo1.ShowUserInfo.showUserInfo(ShowUserInfo.java:6)
at demo1.Client.main(Client.java:6)
虽然编译可以通过，但是并不能正常运行。所以子类在实现父类抽象方法的时候，不应只是能编译通过的实现，而是完全遵照父类方法约定的实现，
不能重写父类的非抽象方法，并不是java编译器强制要求的，重写父类方法也是改造父类拓展父类功能的一种形式，但是这种改造和拓展是有风险的，一个良好的设计应该规避这种形式。
如果一个类UserInfo3继承AUserInfo后，不仅实现了父类的抽象方法，还重写了父类的非抽象方法。代码如下：
public class UserInfo3 extends AUserInfo {
@Override
public String getTitle() {
return "个人资料";
}
@Override
public String getName() {
return "Naya";
}
}
通过场景类在展示其信息时
public class Client {
public static void main(String args[]) {
ShowUserInfo.showUserInfo(new UserInfo3());
}
}
运行后，打印信息如下：
个人资料
姓名：Naya
代码虽然运行正常，但是也在代码中挖了个坑，由于抽象类AUserInfo是为展示用户信息定制的，其子类遵从父类的约定，应该均是用户信息类，但是，在使用工具类ShowUserInfo毫无顾忌地展示用户信息时，一不留神就掉坑里了，发现展示的不是用户信息而是个人资料。
二、子类可以增加自己特有的方法
父类一般是由众多实体对象提取共性向上抽取而来，而子类是对父类共性的个性实现，父类共性是子类的规范也是一种约束，这种约束在一定程度上限制了子类的功能，在一些特殊应用场景中，子类需要打破常规，摆脱束缚，颠覆传统，彰显个性，在父类共性范围之外增加自己特有的方法。
例如有一汽车抽象类，拥有行驶方法
public abstract class AbstractCar {
public abstract void run();
}
传统汽车CommonCar和自动驾驶汽车AutomaticCar均继承自AbstractCar
public class CommonCar extends AbstractCar{
@Override
public void run() {
System.out.println("汽车行驶");
}
}
public class AutomaticCar extends AbstractCar{
@Override
public void run() {
System.out.println("汽车行驶");
}
public void autoRun(){
System.out.println("自动行驶");
}
}
自动驾驶汽车，除了实现父类共有的行驶方法run()外，还有自己特有的方法autoRun()。
在场景类Client中
public class Client {
public static void main(String args[]){
drive(new CommonCar());
drive(new AutomaticCar());
autoDrive(new AutomaticCar());
}
public static void drive(AbstractCar car){
car.run();
}
public static void autoDrive(AutomaticCar car){
car.autoRun();
}
}
AutomaticCar既可以像传统汽车那样，被驾驶方法drive(AbstractCar car)驾驶，也可以被自动驾驶方法autoDrive(AutomaticCar car)驾驶，发挥自己特有的自动行驶autoRun()功能。
三、当子类重载父类的方法时，方法的形参要比父类更宽松
对于重载的方法具有相同的方法名，不同的方法形参，包括个数不同和个数相同但类型不同两种情况。当调用形参个数相同但类型不同的重载方法时，会根据传入参数的类型在重载方法中找形参类型与传入参数最接近的那个方法。
如果子类方法的形参比父类更严格，那么在传入参数与子类更接近的情况下，子类的方法将会覆盖父类的方法而执行。这便相当于重写了父类的非抽象方法。
例如有一父子关系类如下：
public class Father {
public int count(List<Integer> list) {
int sum = 0;
for (int i : list) {
sum += i;
}
return sum;
}
}
public class Son extends Father {
public int count(ArrayList<Integer> list) {
return list.size();
}
}
父类中有一统计方法count,用来计算list集合中元素的加和，子类重载父类的统计方法count但是参数类型比父类更严格，用来统计list集合中元素的个数。
场景类中使用如下：
public class Client1 {
public static void main(String args[]) {
Father father = new Father();
Son son = new Son();
System.out.println(father.count(getList()));
System.out.println(son.count(getList()));
}
private static ArrayList<Integer> getList() {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
return list;
}
}
运行之后发现父子类相同的方法，传入相同的参数，执行结果却是不一致的。一个统计的是元素加和，另一个统计的是元素个数，这与子类可以拓展父类的功能，但是不能改变父类原有的功能相矛盾。
如果子类在重载父类方法时，方法的形参比父类更宽松，代码如下：
public class Son extends Father {
public int count(Collection<Integer> list) {
return list.size();
}
}
则在场景类中，再运行时，将会得到相同的结果。
四、当子类重载父类的方法时，方法的返回值要比父类更严格
在上面的例子中，添加两个具有父子关系的数据源类FatherSource和SonSource,代码如下：
public class FatherSource {
public List<Integer> getList(ArrayList<Integer> list) {
list.clear();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
return list;
}
}
public class SonSource extends FatherSource {
public Collection<Integer> getList(List<Integer> list) {
list.clear();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
return list;
}
}
然后在场景类Client2中，通过上述修改后的Son类对数据源进行统计
public class Client2 {
public static void main(String args[]) {
Son son = new Son();
FatherSource fatherSource = new FatherSource();
SonSource sonSource = new SonSource();
List list = new ArrayList<>();
System.out.println(son.count(fatherSource.getList((ArrayList<Integer>) list)));
System.out.println(son.count(sonSource.getList(list)));
}
}
运行之后发现，采用相同的统计工具类，对不同的数据源数据进行统计，一个被统计出了数据加和，另一个被统计出了数据个数，因为子类方法的返回值比父类更宽松，导致本可以用来处理父类返回数据的统计方法无法适用于子类的返回数据，在处理子类返回数据时采用了具有更宽泛形参的统计方法，最终导致子类数据与父类数据采用了不同的统计方案。
如果当子类重载父类的方法时，方法的返回值要比父类更严格，则不会出现上述问题
例如将上述子类的返回值由Collection改为ArrayList
public class SonSource extends FatherSource {
public ArrayList<Integer> getList(List<Integer> list) {
list.clear();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
return (ArrayList<Integer>) list;
}
}
再次运行场景类将会得到相同的结果
