java向上转型的作用

java向上转型的作用

关于向上转型的作用,我们从一段代码引入:

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的睡觉方法为静态方法,可以总结如下:
如果是访问成员变量,编译的话就是看父类,运行同样是看父类
如果访问的方法,编译就看父类,运行则看子类
如果是静态方法,编译和运行都是看父类

那么向上转型的具体作用是什么,可以通过下面两端代码做个比较:

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

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

}

class Dog extends Animal {
    public void run() {
        System.out.println("小狗在跑");
    }

    public void sleep() {
        System.out.println("小狗睡觉");
    }
}

public class Cat extends Animal {
    public void run() {
        System.out.println("小猫在跑");

    }

    public void sleep() {
        System.out.println("小猫在睡觉");
    }

    public void eat() {
        System.out.println("小猫在吃");
    }

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

    public static void show(Animal am) {//父类实例作为参数
        am.run();
        am.sleep();
    }
}

以上代码中:

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

    public static void show(Animal am) {//父类实例作为参数
        am.run();
        am.sleep();
    }

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

public static void main(String[] args) {
        show(new Dog());
        show(new Cat());
    }

    public static void show(Dog dog) {
        dog.run();
        dog.sleep();
    }
    public static void show(Cat cat) {
        cat.run();
        cat.sleep();
    }

试想一下,一旦有很多子类,那么这个工作量将会比没有使用向上转型大很多。这也表明向上转型还有个优点就是提高了代码的简洁性。
总结
向上类型转换(小转大):
语法规则:<父类型> <引用变量名> = new <子类型>();
1.此时通过父类引用变量调用的方法是子类覆盖或继承
父类的方法,不是父类的方法。
2.此时通过父类引用变量无法调用子类特有的方法。

Q:
向上转型虽然使代码变得简洁,体现了JAVA的抽象编程思想,但是也出现了上面提到的子类无法调用其独有的方法,这要怎么解决呢?所以就有了与之对应的向下转型,弥补了向上转型所带来的缺陷。

借鉴博客:
https://blog.csdn.net/TNTZS666/article/details/80273986

发布了63 篇原创文章 · 获赞 4 · 访问量 3405
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 1024 设计师: 上身试试

分享到微信朋友圈

×

扫一扫,手机浏览