里氏代换原则(Liskov Substitution Principle, LSP)：所有引用基类（父类）的地方必须能透明地使用其子类的对象

里氏代换原则告诉我们，在软件中将一个基类对象替换成它的子类对象，程序将不会产生任何错误和异常，反过来则不成立，如果一个软件实体使用的是一个子类对象的话，那么它不一定能够使用基类对象。例如：我喜欢动物，那我一定喜欢狗，因为狗是动物的子类；但是我喜欢狗，不能据此断定我喜欢动物，因为我并不喜欢老鼠，虽然它也是动物。

      例如有两个类，一个类为BaseClass，另一个是SubClass类，并且SubClass类是BaseClass类的子类，那么一个方法如果可以接受一个BaseClass类型的基类对象base的话，如：method1(base)，那么它必然可以接受一个BaseClass类型的子类对象sub，method1(sub)能够正常运行。反过来的代换不成立，如一个方法method2接受BaseClass类型的子类对象sub为参数：method2(sub)，那么一般而言不可以有method2(base)，除非是重载方法。

      里氏代换原则是实现开闭原则的重要方式之一，由于使用基类对象的地方都可以使用子类对象，因此在程序中尽量使用基类类型来对对象进行定义，而在运行时再确定其子类类型，用子类对象来替换父类对象。

      在使用里氏代换原则时需要注意如下几个问题：

      (1)子类的所有方法必须在父类中声明，或子类必须实现父类中声明的所有方法。根据里氏代换原则，为了保证系统的扩展性，在程序中通常使用父类来进行定义，如果一个方法只存在子类中，在父类中不提供相应的声明，则无法在以父类定义的对象中使用该方法。

      (2)  我们在运用里氏代换原则时，尽量把父类设计为抽象类或者接口，让子类继承父类或实现父接口，并实现在父类中声明的方法，运行时，子类实例替换父类实例，我们可以很方便地扩展系统的功能，同时无须修改原有子类的代码，增加新的功能可以通过增加一个新的子类来实现。里氏代换原则是开闭原则的具体实现手段之一。

      (3) Java语言中，在编译阶段，Java编译器会检查一个程序是否符合里氏代换原则，这是一个与实现无关的、纯语法意义上的检查，但Java编译器的检查是有局限的。

接受的参数（类型）范围比父类大，返回的类型范围比父类小。可以理解为子类比父类强，父亲能干的事情儿子一定可以，反过来不一定成立。

里氏代换原则（ Liskov Substitution Principle）是指：一个软件实体如果使用的是基类的话， 那么也一定适用于其子类， 而且它根本觉察不错使用的是基类对象还是子类对象； 反过来的代换这是不成立的， 即： 如果一个软件实体使用一个类的子类对象，那么它不能够适用于基类对象。 - 里氏代换原则是实现开放封闭原则的具体规范。这是因为： 实现开放封闭原则的关键是进行抽象，而继承关系又是抽象的一种具体实现，这样LSP就可以确保基类和子类关系的正确性，进而为实现开放封闭原则服务。如图：

-举例说明： - 法海的任务是降妖除魔、造福众生。凡是妖魔现身，法海必定全力诛灭之

 

 

妖魔基类

public abstract class Spirit {

       /*

        * 妖魔的行为方法

        */

        public abstract void say();

    }

蛇妖基类

public abstract class Snake extends Spirit{

        /*

        * 蛇妖的基类，继承妖魔，可以扩展方法属性

        */

        @Override

        public void say() {

 

        }

    }

白蛇类：

 public class WhiteSnake extends Snake{

        /*

        * 白蛇对蛇妖的继承实现

        */

        @Override

        public void say() {

          System.out.print("我是白蛇");

        }

    }

测试：

public class Test{

        public static void main(String[] args){

            Spirit spirit=new WhiteSnake();

            spirit.say();

        }

    }

程序运行结果：

我是白蛇

 温馨提示：

里氏代换原则是很多其它设计模式的基础。它和开放封闭原则的联系尤其紧密。违背了里氏代换原则就一定不符合开放封闭原则。

接受的参数（类型）范围比父类大，返回的类型范围比父类小。可以理解为子类比父类强，父亲能干的事情儿子一定可以，反过来不一定成立。

接受的参数（类型）范围比父类大，返回的类型范围比父类小。可以理解为子类比父类强，父亲能干的事情儿子一定可以，反过来不一定成立

首先，这是编译器的要求，如果不这么做，无法通过编译。
其次，面向对象的编程，其中继承有个大原则，任何子类的对象都可以当成父类的对象使用。

如有父类人类，可以使用一般的枪，有警察类，可以使用任何的枪。
class Person {
void shoot(SimpleGun simpleGun);
}
class Police extends Person {
void shoot(Gun gun);

}
其中SimpleGun extends Gun。

这样的话任何警察类的对象都可以被当做人类来使用。
也就是说警察类既然会使用任何的枪，当然可以使用一般的枪。
Person person = new Police();
person.shoot(simpleGun);

而如果反过来，普通人可以使用任何抢，警察只能使用一般枪。
class Person {
void shoot(Gun gun);
}
class Police extends Person {
void shoot(SimpleGun simpleGun);

}
这样的话就不合理了，既然警察是人类的一个子类，所以警察也是人类，既然是人类就应该能使用人类的方法，也就是使用任何的枪，可以根据上面的定义，反而警察类的能力还变小了。

所以有一个原则，子类的能力必须大于等于父类，即父类可以使用的方法，子类都可以使用。

返回值也是同样的道理。
假设一个父类方法返回一个List，子类返回一个ArrayList，这当然可以。
如果父类方法返回一个ArrayList，子类返回一个List，就说不通了。
这里子类返回值的能力是比父类小的。

还有抛出异常的情况。
任何子类方法可以声明抛出父类方法声明异常的子类。
而不能声明抛出父类没有声明的异常。

这一切都是为了，任何子类的对象都可以当做父类使用。

所谓里氏替换原则，就是让你的某一段程序耦合于基类或者接口，而不是具体继承了基类的子类或实现接口的具体类型。仅替换子类不会让你这个程序的属性有所改变。
所谓多态机制，则是给了你达成上述原则的其中一种能力。

举个栗子来说，同样是list基类/接口，子类可以是用array实现也可以用linkedlist实现，但都必须实现at方法（得到具体某个index的值）。你现在用list实现了一个找最小值的算法，我们假设你是一个个遍历过去找的，那么不管底下是array实现还是linkedlist实现（子类替换），你的算法都应该是返回最小值（属性不变），只是用linkedlist的时候很蠢。而你知道at方法对于array和linkedlist实现是不一样的，list调用at的时候根据底下具体的实现决定调用哪一个，这货就叫做多态。