《设计模式》里氏替换原则

里氏替换原则

定义

定义1

如果对每一个类型为S的对象o1，都有类型为T的对象o2，使得以T定义的所有程序P在所有的对象o1都代换成o2时，程序P的行为没有发生变化，那么类型S是类型T的子类型。

定义2

所有引用基类的地方必须能透明地使用其子类的对象。

通俗点讲，只要父类能出现的地方子类就可以出现。

对定义的解释

1.子类必须完全实现父类的方法

什么意思呢？且看下列代码。

// 定义一个抽象的枪支类
public abstract class AbstractGun {
    public abstract void shoot();
}

// 定义一个士兵类
public class Soldier {
    AbstractGun gun;

    public void setGun(AbstractGun gun) {
        this.gun = gun;
    }

    void killEnemy(){
        System.out.println("the soldier is beginning killing...");
        gun.shoot();
    }
}

下面表示三个枪支的实现类（子类），分别是手枪，步枪和机枪。

接下来是手枪和步枪的代码

public class HandGun extends AbstractGun{
    @Override
    public void shoot() {
        System.out.println("using handgun,shoot!");
    }
}

public class Rifle extends AbstractGun{
    @Override
    public void shoot() {
        System.out.println("using rifle,shoot!");
    }
}

当我们创建一个士兵，并给他赋予枪支的时候，他是不知道他所拿的是什么类型的枪支的，因为setGun()传入的是一个父类的类型的参数，他只知道他的枪能射击（也就是父类拥有的功能）。

假使传入的枪的子类没有实现shoot方法，看下面的焊枪的例子，众所周知，焊枪是没有射击功能的，所以下面shoot方法里没有任何东西，也就是没有实现这个功能。

public class WeldingGun extends AbstractGun {
    @Override
    public void shoot() {

    }
    
    public void weld(){
        System.out.println("welding...");
    }
}

在士兵调用方法杀死敌人的时候，是杀不死的，因为枪没有实现射击功能。等同于这个时候父类出现的地方，子类不可以出现（子类功能没出现），显然这违反了里氏替换原则，这给我们带来的后果是：没有实现我们预期的业务功能。

    public static void main(String[] args) {
        Soldier soldier = new Soldier();
        WeldingGun weldingGun = new WeldingGun();
        soldier.setGun(weldingGun);
        soldier.killEnemy();
    }

输出结果

the soldier is beginning killing...

而当子类实现分类方法的时候，这就满足了，父类出现的地方，子类就可以出现的原则。换句话说，就是在子类完全实现父类的方法的前提下，里氏替换原则才可以成立。里氏替换原则成立，业务也得以按预期进行。

    public static void main(String[] args) {
        Soldier soldier = new Soldier();
        Rifle rifle = new Rifle();
        soldier.setGun(rifle);
        soldier.killEnemy();
        HandGun handGun = new HandGun();
        soldier.setGun(handGun);
        soldier.killEnemy();
    }

输出结果

the soldier is beginning killing...
using rifle,shoot!
the soldier is beginning killing...
using handgun,shoot!

2.子类可以有自己的个性

子类要实现所有的父类功能，那是不是意味着子类不可以有自己的个性呢？非也。下面我们扩展手枪，创建一支神枪手专门使用的枪。它同时拥有调整位置和射击的功能。

public class Spy extends HandGun {
    @Override
    public void shoot() {
        System.out.println("using Spy,shoot!");
    }

    public void adjust(){
        System.out.println("adjust the position...");
    }
}

下面是一个神枪手。

public class Sharpshooter extends Soldier{

    void killEnemy(Spy spy) {
        spy.adjust();
        spy.shoot();
    }
}

进行射击

    public static void main(String[] args) {
        Sharpshooter sharpshooter = new Sharpshooter();
        Spy spy = new Spy();
        sharpshooter.killEnemy(spy);

    }

输出结果

adjust the position...
using Spy,shoot!

显然，这里的子类Spy有自己特有的个性，而且同时也实现了父类的shoot方法。

3.覆盖或实现父类的方法时输入参数可以被放大，但不能缩小

假设我们有一个武器类（Weapon），并且其有一个扩展类是刀（Knife）。

public  class Weapon {
    public void useTimes(Integer integer) {
        System.out.println("weapon is using");
    }

}

public class Knife extends Weapon {

    public void useTimes(Number number) {
        System.out.println("Knife using..." );
    }


}

显然Number的范围要大于Integer，注意这里没有重写父类的方法只是重载，所以我们调用setTimes方法的时候，并不希望子类setTimes方法执行，因为这样会导致逻辑混乱。按照里氏替换原则， 父类出现的地方子类就可以出现。那我们这样做了，将输入放大了，会得到预期结果吗？

    public static void main(String[] args) {
        Weapon weapon = new Weapon();
        Knife knife = new Knife();
        Integer integer = 1;
        weapon.useTimes(integer);
        knife.useTimes(integer);
    }

输出结果

weapon is using
weapon is using

显然是如此，在子类出现的时候，我们得到了父类的方法调用。

那反过来呢？我们将两个方法的输入范围倒置一下

public  class Weapon {
    public void useTimes(Number number) {
        System.out.println("weapon is using");
    }
}

public class Knife extends Weapon {

    public void useTimes(Integer integer) {
        System.out.println("Knife using..." );
    }
}

然后再次执行

 public static void main(String[] args) {
        Weapon weapon = new Weapon();
        Knife knife = new Knife();
        Integer integer = 1;
        weapon.useTimes(integer);
        knife.useTimes(integer);
    }

输出结果

weapon is using
Knife using...

也就是说我们在没有覆写父类的方法的时候，调用了父类的方法名，结果却得到了子类的调用，显然逻辑混乱了。

4.覆写或实现父类的方法时输出结果可以被缩小