重学Java（031）—— Java基础知识（对象的向上转型、对象的向下转型、instanceof关键字）

一、对象的向上转型

对象的向上转型，其实就是多态的写法：

格式：

父类名称 对象名 = new 子类名称();

可以把它看作是右侧创建一个子类对象，把它当作父类来看待使用。

要注意的是：**向上转型一定是安全的。**从小范围转向大范围，这是一定没有问题的。

类似于：

double num = 100; // 正确，int —> double,自动类型转换

下面通过代码简单示例：

首先创建一个父类Animal，定义一个抽象方法eat()：

public abstract class Animal {

    public abstract void eat();

}

然后创建一个子类Cat，覆盖重写eat()方法：

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

最后创建测试类：

public class Demo01Main {

    public static void main(String[] args) {
        // 对象的向上转型，就是：父类引用指向子类对象。
        Animal animal = new Cat();
        animal.eat();
    }

}

二、对象的向下转型

对象的向下转型，其实是一个【还原】的动作。

格式：

子类名称 对象名 = (子类名称) 父类对象；

含义：将父类对象，【还原】成为本来的子类对象。

例如：

Animal animal = new Cat(); // 本来是猫，向上转型成为动物
Cat cat = (Cat) animal; // 本来是猫，已经被当作动物了，还原回来成为原本的猫

注意事项：

1. 必须保证对象本来创建的时候就是猫，才能向下转型为猫
2. 如果对象创建的时候本来不是猫，现在硬要向下转型成为猫，就会报错了。

---

继续观察向上转型的例子，如果我们在子类中添加一个自己特有的方法，例如：

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void catchMouse() {
        System.out.println("猫捉老鼠");
    }
}

此时我们在测试类中，能够通过向上转型后的对象animal来调用catchMouse()这个方法吗？答案是否定的。因为：对象一旦向上转型为父类，就无法调用子类原本特有的内容。

这个时候我们就要用到对象的向下转型了，将animl进行还原还原成猫，再通过猫，就可以调用Cat的特有方法了，代码如下：

public class Demo01Main {

    public static void main(String[] args) {
        // 对象的向上转型，就是：父类引用指向子类对象。
        Animal animal = new Cat(); // 本来创建的时候是一只猫
        animal.eat(); // 猫吃鱼

//        animal.catchMouse(); // 错误写法

        // 向下转型，进行还原操作
        Cat cat = (Cat) animal;
        cat.catchMouse(); // 猫抓老鼠
    }

}

---

再来设想一种情况：原本我们通过猫向上转型成为动物，现在如果要通过动物向下转型成为狗，而不是成为猫，这样可以吗？显然是不行的。

下面代码简单说明：

再定义一个Animal的子类Dog，覆盖重写eat()方法，再定义一个自己特有的方法：

public class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void lookHouse() {
        System.out.println("看门狗");
    }
 }

我们再测试类中，添加向下转型的代码，尝试将动物向下转型为狗，看看会发生什么：

public class Demo01Main {

    public static void main(String[] args) {
        // 对象的向上转型，就是：父类引用指向子类对象。
        Animal animal = new Cat(); // 本来创建的时候是一只猫
        animal.eat(); // 猫吃鱼

//        animal.catchMouse(); // 错误写法

        // 向下转型，进行还原操作
        Cat cat = (Cat) animal;
        cat.catchMouse(); // 猫抓老鼠

        // 下面是错误的向下转型：
        // 本来new的时候是一只猫，现在非要当作狗
        // 错误写法，编译不会报错，但是运行会出现异常。
        // java.lang.ClassCastException，类转换异常
        Dog dog = (Dog) animal;
    }

}

运行后会报错，如下图所示：

类似于：

int num = (int) 10.0; // 可以

int num = (int) 10.5; // 不可以，精度损失

三、instanceof关键字

如何才能知道一个父类引用的对象本来是什么子类？

格式：
对象 instanceof 类型

这将会得到一个boolean值结果，也就是判断前面的对象能不能当作后面类型的实例。

下面简单展示一个案例：

public class Demo02Instanceof {

    public static void main(String[] args) {
        Animal animal = new Cat(); // 本来是一只猫
        animal.eat();

        // 如果希望调用子类特有方法，需要向下转型

        // 判断一下父类引用animal本来是不是Dog
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.lookHouse();
        }

        // 判断一下animal本来是不是cat
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }


        giveMeAPet(new Dog());

    }

    public static void giveMeAPet(Animal animal) {

        // 如果是狗，就看门狗
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.lookHouse();
        }

        // 如果是猫，就抓老鼠
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
    }

}