Java>多态>>对象的向上、向下转型的区别

最新推荐文章于 2022-01-12 18:38:30 发布

小菜鸟进阶史

最新推荐文章于 2022-01-12 18:38:30 发布

阅读量470

点赞数 2

CC 4.0 BY-SA版权

分类专栏： Java语言高级文章标签： Java 编程语言

本文链接：https://blog.csdn.net/qq_36050720/article/details/97664319

Java语言高级专栏收录该内容

45 篇文章

订阅专栏

本文探讨了Java中的对象向上转型和向下转型。向上转型是多态的体现，允许将子类对象视为父类使用，但会丢失子类特有功能。向下转型用于恢复子类特性，需要先通过`instanceof`判断，错误的转型会导致`ClassCastException`。

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

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

Animal animal = new Cat();

含义：右侧创建一个子类对象，把它当做父类来看待使用。

创建了一只猫，当做动物看待，没问题

注意事项：

向上转型一定是安全的。从小范围转向了大范围，从小范围的猫，向上转换成更大范围的动物。

但是也有一个弊端：对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。

解决方案：用对象的向下转型【还原】。

2.对象的向下转型，其实就是一个【还原】的动作：

格式：子类名称对象名 = (子类名称) 父类对象；

Animal animal = new Cat(); // 本来是猫，向上转型成为动物

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

Cat cat = (Cat)animal; // 本来是猫，已经被当做动物了，还原回来成为本来的猫

注意事项：

a. 必须保证对象本来创建的时候，就是猫，才能向下转型成为猫

b. 如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错（java.lang.ClassCastException）。

类似于： int num = (int) 10.0; // 可以 int num = (int) 10.5 // 不可以，精度损失

3.对象的向下转型，一定要进行instanceof关键字判断：

格式：对象 instanceof 类名称

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

实例如下：

创建一个父类Animal：

package DuoTai;

//父类Animal

public abstract class Animal {

    public abstract void eat();

}

创建一个子类Cat继承父类Animal：

package DuoTai;

//子类Cat

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

    //这个是子类特有方法
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

创建一个子类Dog继承父类Animal：

package DuoTai;

//子类Dog

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

    public void watchHouse(){
        System.out.println("狗看家");
    }
}

创建一个Demo01Main类使用父子类：

package DuoTai;

public class Demo01Main {
    public static void main(String[] args) {

        // 对象的向上转型，就是：父类引用指向子类对象
        Animal animal = new Cat();
        animal.eat();
        System.out.println("=====================");

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

        // 向下转型，进行【还原】动作
        Cat cat = (Cat) animal;
        cat.catchMouse();

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

    }
}

以上代码运行结果：

猫吃鱼
=====================
猫抓老鼠

创建一个Demo02Instanceof类使用父子类：

package DuoTai;

/*
如何才能知道一个父类引用的对象，本来是什么子类？
格式：
对象 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.watchHouse();
        }
        //判断一下animal本来是不是Cat
        if(animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }

        System.out.println("==================");

        giveMePet(new Dog());
    }

    public static void giveMePet(Animal animal){
        if(animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        if(animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
    }
}

以上代码运行结果：

猫吃鱼
猫抓老鼠
==================
狗看家