里氏替换原则

在说原则之前先回忆几个定义：
一、重写与重载的区别：
1)重写(Override):
1.1)发生在父子类中，方法名相同，参数列表相同，方法体不同
1.2)重写遵循"运行期"绑定，看对象的类型来调用方法
2**)重载(Overload)?*
2.1)发生在一个类中，方法名相同，参数列表不同，方法体不同
2.2)重载遵循"编译期"绑定，看引用的类型来绑定方法

二、继承具有传递性
子类可以重写(覆盖)继承自父类的方法，即方法名和参数列表与父类的方法相同；
子类利用重写修改父类的方法。当子类对象的重写方法被调用时（无论是通过子类
的引用调用还是通过父类的引用调用），运行的是子类的重写修改后的版本

三、重写两同两小一大
两同：方法名和参数列表（方法签名）必须相同
两小：返回值类型、声明异常 比（被重写的）父类的小（或一样）
一大：访问修饰符比（被重写的）父类的大（或一样）

下面开始正题：
里氏替换原则定义：
第一种定义：如果对每一个类型为S的对象o1，都有类型为T的对象o2，使得以T定义的所有程序P在所有的对象o1都代换成o2时，程序P的行为没有发生变化，那么类型S是类型T的子类型。
第二种定义：所有引用基类的地方必须能透明地使用其子类的对象。

第二种定义比较通俗，容易理解：只要有父类出现的地方，都可以用子类来替代，而且不会出现任何错误和异常。但是反过来则不行，有子类出现的地方，不能用其父类替代。

四层含义
里氏替换原则对继承进行了规则上的约束，这种约束主要体现在四个方面：

1. 子类必须实现父类的抽象方法，但不得重写（覆盖）父类的非抽象（已实现）方法。

public class Father {

    public void demo(int a){
        System.out.println("Father的demo方法"+a);
    }
}

public class Son extends Father{
        public void demo(int a){
            System.out.println("Son的demo方法"+a);
        }
    }
    
public class TestDemo{
        public static void main(String[] args) {
            Father father = new Father();
            father.demo(1);
            Son son = new Son();
            son.demo(2);
        }
    }

运行结果：

这里子类把父类方法重写（覆盖）了，这就没有遵循里氏替换原则，遵循的话应该是输出两个“Father的demo方法1”才对

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

public class Father {

    public void demo(int a){
        System.out.println("Father的demo方法"+a);
    }
}

public class Son extends Father{
        public void newdemo(int a){
            System.out.println("Son的demo方法"+a);
        }
    }
    
 public class TestDemo{
        public static void main(String[] args) {
            Father father = new Father();
            father.demo(1);
            Son son = new Son();
            son.demo(2);
            son.newdemo(3);
        }
    }

运行结果：

子类没有覆盖父类，添加了自己的新类，这里属于里氏替换原则。

3. 当子类覆盖或实现父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。

public class Father {

    public void demo(HashMap hashMap){
        System.out.println("Father的demo方法");
    }
}

   public class Son extends Father{
        public void demo(Map map){
            System.out.println("Son的demo方法");
        }
    }
    
   public class TestDemo{
        public static void main(String[] args) {
            HashMap hashMap = new HashMap();
            Father father = new Father();
            father.demo(hashMap);
            Son son = new Son();
            son.demo(hashMap);
        }
    }

运行结果：

注：此处子类并非重写了父类的方法，而是重载了父类的方法。因为子类和父类的方法的输入参数是不同的。子类方法的参数Map比父类方法的参数HashMap的范围要大，所以当参数输入为HashMap类型时，只会执行父类的方法，不会执行子类的重载方法。这符合里氏替换原则（不明白的看上面定义）

4. 当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。

public abstract class Father {
    public abstract Map fun();
}
  public class Son extends Father{
        @Override
        public HashMap fun(){
           HashMap hashMap = new HashMap();
           hashMap.put("子类","子类被执行");
           return hashMap;
        }
    }
  public class TestDemo{
        public static void main(String[] args) {
            Father father = new Son();
            System.out.println(father);
        }
    }

运行结果：

若在继承时，子类的方法返回值类型范围比父类的方法返回值类型范围大，在子类重写该方法时编译器会报错。

参考：https://www.jianshu.com/p/cf9f3c7c0df5