/*
* 多态的缺点: 使用父类引用无法访问子类所特有的方法
*
* 解决办法: 向下转型
*
* 基本类型存在自动类型转换和强制类型转换
* 引用类型存在向上转型和向下转型
*
* 向上转型(自动转换)
* 格式:<父类型> <引用变量名> = new <子类型>();
* 特点:
* 子类转为父类 父类的引用指向子类对象。理解为自动进行类型转换
* 此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法
* 此时通过父类引用变量无法调用子类特有的属性和方法
*
* 向下转型(强制转换)
* 格式:<子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;
* 特点:
* 父类转为子类,父类引用转为子类对象。理解为强制类型转换
* 在向下转型的过程中,如果没有转换为真实子类类型,会出现类型转换异常
*
* java.lang.ClassCastException
* 异常名称: 类型转换异常
* 产生原因: 在向下转型的过程中,没有转换成真实的类型
* 解决办法: 在每次向下转型之前做一个类型的判断
*
* 类型判断的语法: instanceof
* 左边对象 instanceof 类名 这个表达式的结果是boolean类型
* 测试它左边的对象是否是它右边的类的实例
*
* 多态的弊端可以使用instanceof关键字+向下转型来解决
* 我们知道我们需要对父类的所有子类做逐一判断,违背了开闭原则
*
* 为了开闭原则我们还是可以继续开发,但是如果这个父类引用是Object呢?
* 无法做逐一个判断,安全隐患一致存在,后面可以考虑是泛型。(后面讲解)
*
*/
public class DuoTaiDemo04 {
public static void main(String[] args) {
// Car c = new BMW();
// c.run();
// 想要访问BMW的fillOil,无法访问
// 利用向下转型
// BMW bmw = (BMW) c;
// bmw.fillOil();
//
// c = new Benz();
// c.run();
// Benz benz = (Benz) c;
// benz.leakOli();
// BMW bmw2 = (BMW) c;
// bmw2.fillOil();
// System.out.println(c instanceof BMW);
// System.out.println(c instanceof Benz);
Car c = new Benz();
c.run();
c = new BYD();
c.run();
if (c instanceof Benz) {
Benz benz = (Benz) c;
benz.leakOli();
} else if (c instanceof BMW) {
BMW b = (BMW) c;
b.fillOil();
} else if (c instanceof BYD) {
BYD byd = (BYD) c;
byd.electric();
}
Object obj = new BMW();
}
}
class Car {
public void run() {
System.out.println("Car.run()");
}
}
class BMW extends Car {
@Override
public void run() {
System.out.println("BMW.run()");
}
public void fillOil() {
System.out.println("加油");
}
}
class Benz extends Car {
@Override
public void run() {
System.out.println("Benz.run()");
}
public void leakOli() {
System.out.println("漏油");
}
}
class BYD extends Car {
@Override
public void run() {
System.out.println("BYD.run()");
}
public void electric() {
System.out.println("充电");
}
}
多态的缺点以及向上转型_向下转型
猜你喜欢
转载自blog.csdn.net/weixin_44083591/article/details/89788515
今日推荐
周排行