Java向上转型的作用（有详细代码介绍）

在一道题目中 当时对于主函数中
Car car =(Car) new Benz();
不是很理解，也并不知道有什么意义，因为如果仅仅写Car car = new Benz(); 程序运行结果是一样的。
在经过阅读书籍和查看别的博主写的关于向上向下转型的博客后，发现题目中这么写完全就是为了出题用，它和仅仅写Car car = new Benz(); 是一样的，都是向上转型。但是相信还是会有人对于向上转型意义不太明白，所以我这里就这道题写一下关于向上转型的用法。
首先为了大家更好的理解，我对题目的程序进行了改动，增加一个price()方法。
改动后的程序如下：

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();程序报错
    }
}

此时程序运行后输出：

但是当我们用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();
}

试想一下，一旦有很多子类，那么这个工作量将会比没有使用向上转型大很多。这也表明向上转型还有个优点就是提高了代码的简洁性。

总结
向上类型转换（小转大）：
语法规则：<父类型> <引用变量名> = new <子类型>();
1.此时通过父类引用变量调用的方法是子类覆盖或继承
父类的方法，不是父类的方法。
2.此时通过父类引用变量无法调用子类特有的方法。

敲黑板
向上转型虽然使代码变得简洁，体现了JAVA的抽象编程思想，但是也出现了上面提到的子类无法调用其独有的方法，这要怎么解决呢？所以就有了与之对应的向下转型，弥补了向上转型所带来的缺陷。关于向下转型我会在下一次的博客中给出例子。希望对大家有帮助。
原文链接：https://blog.csdn.net/TNTZS666/article/details/80273986