用例子理解里氏替换原则：
需求：

（1）设计宠物类，猫类，狗类，让猫和狗继承宠物类

（2）在宠物类中定义sound方法，表示宠物的叫声，但是叫声不能由具体的行为。

（3）猫和狗重写父类的sound方法，以实现具体的叫声

代码如下：

class Pet {//宠物
    public void sound() throws RuntimeException{

    }
}
class Dog extends Pet {//狗

    //方法重写
    @Override
    public void sound() {
        System.out.println("汪汪汪");
    }
}
class Cat extends Pet{//猫
    //方法重写
    @Override
    public void sound() throws RuntimeException{
        System.out.println("喵喵喵");
    }
}

开一个宠物店，创建出要卖的猫和狗。顾客在购买宠物时要求宠物叫一声，以此判断是否买它。

宠物店代码如下：

public class PetShop{//宠物店
    public static void main(String[] args) {
        Dog dog = new Dog();
    }
}

此时第3行的代码运行时，内存中分配了狗的实例，如下图：

内存图

当宠物店中代码中

Dog dog = new Dog();

这样写就只能卖狗了。

如果顾客还想看看猫，怎么办？再new个猫

public class PetShop{//宠物店
    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();
    }
}

此时内存分配如下：

内存图

顾客要买的是宠物，可能是猫，可能是狗，若以顾客希望的是宠物叫，而不是具体的猫叫或狗叫。

此时可以使用父类引用指向子类实例。

代码重构如下：

public class PetShop{//宠物店
    public static void main(String[] args) {
        Pet pet = null;
        pet = new Dog();//先看看狗,让狗叫一声
    }
}

此时内存是什么样子？

内存图

如果此时pet引用调用sound方法，让宠物叫，那pet调用的是Dog里的sound？还是调用Pet里的sound呢？

    public static void main(String[] args) {
        Pet pet = null;
        pet = new Dog();//先看看狗,让狗叫一声
        pet.sound();//pet调用sound，让宠物叫，实际上调用的是Dog的sound方法
    }

运行结果：
汪汪汪

运行结果说明：

• 父类引用pet 赋值时 赋的是子类对象Dog的实例。就是这行代码 pet = new Dog();

• 我们发现 pet = new Dog(); 这行代码 = 的右侧 new的是子类的实例，而 = 左侧 是父类的引用。我们把这种情况称为“父类引用指向子类实例”

当父类引用指向子类实例时，父类引用可以调用子类的方法，例如pet可以调用Dog的sound方法，狗叫了。

那如果顾客现在有看见猫了，向让猫叫一下。怎么办？

由于父类引用可以调用子类的方法，所以现在可以让pet指向到Cat实例上去，然后pet调用sound，调用的就是Cat的sound方法。

代码修改如下：

    public static void main(String[] args) {
        Pet pet = null;
        pet = new Dog();//先看看狗,让狗叫一声
        pet.sound();//pet调用sound，让宠物叫,其实是狗叫

        pet = new Cat();
        pet.sound();//pet调用sound，让宠物叫,其实是猫叫
    }

运行结果：
汪汪汪
喵喵喵

此时内存的分配如下：

内存图

顾客想看看猫爬树，如果能上树就不买了，此时顾客怎么让猫爬树呢？

是否可以用pet对象调用climb方法，如

    public static void main(String[] args) {
        Pet pet = null;
        pet = new Dog();
        pet.sound();

        pet = new Cat();
        pet.sound();
//        pet.climb();//报错
    }

这是不行的，代码报错。

为什么呢？

因为父类引用调用方法时，必须知道子类有哪些方法，知道的才能调用，不知道的是不能调用的。

子类Cat新增的climb()方法父类并不知道，但是父类一定知道子类从父类继承的方法。

所以父类引用只能调用子类与父类保持继承关系的方法。可以是重写的方法。

一种特殊的情况的说明（子类引用指向父类实例）：

下面的代码是否正确：

    public static void main(String[] args) {
        pet pet = null;
        Dog dog = pet;//报错： 子类引用dog指向父类实例
    }

子类引用指向父类实例报错，原因用内存图说明吧

• 当子类指向父类引用时，子类会丢失数据，因此不允许转换。
• 如果非要转，就要强转，认可丢失的数据。Dog dog = (Dog)pet;

原因用图表示一下

内存图

Pet pet = new Pet();
Pet pet = new Dog();

※里氏替换原则中的调用规则：

• 子类赋给父类（父类引用指向子类实例），允许
• 父类赋给子类（子类引用指向父类实例），强转

里氏替换中的调用规则

• 父类引用只能调用子类从父类继承的方法。
• 当子类重写父类方法后，父类引用调用的是子类重写的方法，否则调用子类从父类继承的方法。