重新精读《Java 编程思想》系列之向上转型与向下转型

…衆ロ難τιáo~ 提交于 2021-02-08 05:18:57

前言

今天重读了一下向上转型与向下转型,有些新的体会,了解了向上转型的好处,及如何向下转型。在此分享给大家。

向上转型

向上转型是用来表现新类和基类之间的关系。在传统中,由导出类转型成基类,在继承图中是向上移动的。因此称作向上转型。由于向上转型是从一个较专用类型向较通用类型转换,所以总是安全的。也就是说,导出类是基类的一个超集。它可能比基类含有更多的方法。但他必须具备基类中所含有的方法。 我们来看一个例子。

class Car {
    public void run() {
        System.out.println("这是父类run()方法");
    }
}

public class Benz extends Car {
    public void run() {
        System.out.println("这是Benz的run()方法");

    }

    public void price() {
        System.out.println("Benz:800000$");
    }

    public static void main(String[] args) {
        Car car = new Benz();
        car.run();
       //car.price();程序报错
    }
}

运行后输出。这是Benz的run()方法。 但是当我们用car这个对象去调用Benz类中price这个方法时,就会报错。 这就是因为我们此处进行的向上转型,car这个对象虽然指向子类,但是子类由于进行了向上转型,就失去了使用父类中所没有的方法的“权利”,在此处就是不能调用price()这个方法。 那么向上转型到底有什么用呢,到目前为止我们不仅看不到它的好处,反而发现使用了向上转型后反而不能调用子类所特有的方法了。那么向上转型的作用到底是什么呢,我们一起来看下面的代码:

class Car {
    public void run() {
        System.out.println("这是父类run()方法");
    }

    public void speed() {
        System.out.println("speed:0");
    }

}

class BMW extends Car {
    public void run() {
        System.out.println("这是BMW的run()方法");
    }

    public void speed() {
        System.out.println("speed:80");
    }
}

public class Benz extends Car {
    public void run() {
        System.out.println("这是Benz的run()方法");

    }

    public void speed() {
        System.out.println("speed:100");
    }

    public void price() {
        System.out.println("Benz:800000$");
    }

    public static void main(String[] args) {
        show(new Benz());//向上转型实现
        show(new BMW());
    }

    public static void show(Car car) {//父类实例作为参数
        car.run();
        car.speed();
    }
}

上面代码中

    public static void main(String[] args) {
        show(new Benz());
        show(new BMW());
    }

    public static void show(Car car) {
        car.run();
        car.speed();
    }

就体现了向上转型的优点,这也体现了Java抽象编程的思想。如果此处没有向上转型,要实现show每个子类的功能,那么有几个子类就要写多少函数。代码如下:

    public static void main(String[] args) {
        show(new Benz());
        show(new BMW());
    }

    public static void show(Benz benz) {
        benz.run();
        benz.speed();
    }
    public static void show(BMW bmw) {
        bmw.run();
        bmw.speed();
    }

试想一下,一旦有很多子类,那么这个工作量将会比没有使用向上转型大很多。这也表明向上转型还有个优点就是提高了代码的简洁性。 我们再来一种带着static的特殊调用情况。

public class Animal {
	
	    String name = "我是动物";
	    static int age = 20;
	    public void eat() {
	        System.out.println("动物可以吃饭");
	    }
	    public static void sleep() {
	        System.out.println("动物可以睡觉");
	    }

	    public void run(){
	        System.out.println("动物可以奔跑");
	    }

	    public static void main(String[] args) {
	        Animal am = new Dog();
	        am.eat();
	        am.sleep();
	        am.run();
	        //am.watchdog();这里会报错
	        System.out.println(am.name);
	        System.out.println(am.age);
	    }

}
class Dog extends Animal {
    String name = "小狗";
    static int age = 60;
    public void eat() {
        System.out.println("小狗可以吃饭");
    }
    public static void sleep() {
        System.out.println("小狗可以睡觉");
    }
    public void watchdog() {
        System.out.println("小狗可以看门");
    }

}

运行结果:

但是可以看到代码块中,直接调用Dog的watchdog()方法会报错。

这就是因为我们此处进行的向上转型,am这个对象虽然指向子类,但是子类由于进行了向上转型,就失去了使用父类中所没有的方法的“权利”,在此处就是不能调用watchdog()这个方法。 而且结果里也可以看到,睡觉是引用的父类“Animal”的睡觉方法,这是因为Animal的睡觉方法为静态方法,可以总结如下: 如果是访问成员变量,编译的话就是看父类,运行同样是看父类。 如果访问的方法,编译就看父类,运行则看子类。 如果是静态方法,编译和运行都是看父类。

向下转型

先看一个错误的例子

public class Animal {
    public void eat(){
        System.out.println("Animal eat()");
    }
}

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

public class Test {
    public static void main(String[] args) {
        //向下转型
        Animal animal = new Animal();
        ((Dog)animal).eat();
    }
}

运行结果: Exception in thread "main" java.lang.ClassCastException: com.hello.test.Animal cannot be cast to com.hello.test.Dog at com.hello.test.Test.main(Test.java:7) 从上述例子来看,Java似乎并不支持向下转型,真是如此吗?其实不然,Java同样支持向下转型,只是向下转型是有条件的——只有引用子类对象的父类引用才能被向下转型为子类对象。也就是说,向下转型之前,必须先向上转型。

public class Animal {
    public void eat(){
        System.out.println("Animal eat()");
    }
}

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

public class Test {
    public static void main(String[] args) {
        //向上转型
        Animal animal = new Dog();
        //向下转型
        ((Dog)animal).eat();
    }
}

运行结果: Dog eat

原文出处:https://www.cnblogs.com/jichi/p/12064038.html

标签
易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!