美文网首页
多态中的向上转型与向下转型

多态中的向上转型与向下转型

作者: 程序员汪汪 | 来源:发表于2021-03-02 02:19 被阅读0次

在讨论向上转型和向下转型之前,先复习下多态。如果有错误的地方,希望能够指出,大家共同进步!

什么是多态?

多态(Polymorphism)即同一操作作用于不同的对象,可以有不同的解释,产生不同的结果。

多态的分类

多态一般分为两种:

  1. 重载式多态

    • 重载式多态,也叫编译时多态。也就是说这种多态在编译时已经确定好了。方法名相同而参数列表不同的一组方法就是重载。在调用这种重载的方法时,通过传入不同的参数最后得到不同的结果。
  2. 重写式多态

    • 重写式多态,也叫运行时多态。这种多态通过动态绑定(dynamic binding)技术来实现,是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。也就是说,只有程序运行起来,你才知道调用的是哪个子类的方法。这种多态通过函数的重写以及向上转型来实现。

多态实现的必要条件

  1. 继承或实现接口

    • 在多态中必须存在有继承关系的子类和父类或者接口及其实现类
  2. 重写

    • 子类对父类中某些方法进行重新定义,再调用这些方法时就会调用子类的方法
  3. 向上转型

    • 父类引用指向子类对象叫做向上转型。

向上转型与向下转型

向上转型,上面已经说了,向下转型是子类引用指向父类对象(父类型,实例是子类的实例化),通常需要进行强制类型转换

案例

//水果类,拥有一个show()方法
class Fruits {

    public void show() {
        System.out.println("我水果之父,打钱!");
    }

}
// 苹果类,实现父类水果,并重写show()方法
class Apple extends Fruits {

    @Override
    public void show() {
        System.out.println("我苹果,打钱!");
    }

    public void color() {
        System.out.println("我是红色的苹果。");
    }
}
// 香蕉类,实现父类水果,并重写show()方法
class Banana extends Fruits {
    @Override
    public void show() {
        System.out.println("我香蕉,打钱!");
    }

    public void color() {
        System.out.println("我是黄色的香蕉。");
    }
}
//测试类
public class Test {

    public static void main(String[] args) {
        //向上转型
        Fruits fruit = new Apple();

        fruit.show();

        fruit = new Banana();

        fruit.show();

    }

}

/**
运行结果:
    我苹果,打钱!
    我香蕉,打钱!
*/

这就是向上转型,Fruits fruit = new Apple();将子类对象Apple转化为父类对象Fruits,这个时候fruit引用指向的是子类对象,所以调用的方法是子类方法。

向上转型的好处

  • 减少重复代码
  • 提高代码扩展性

向上转型需要注意的问题

向上转型时,子类单独定义的方法会丢失。比如,上面案例中的Apple类和Banana类都定义了自己的color方法,当进行了向上转型后,fruit引用指向Apple类的实例时是访问不到color方法的,fruit.color()会报错。

向下转型

子类引用指向父类对象(父类型,实例是子类的实例化),通常需要进行强制类型转换,但是这里有个需要注意的问题。

//还是上面的Fruits、Apple、Banana

Fruits fruit = new Apple(); //向上转型

Apple apple = (Apple)fruit; //向下转型,强制类型转换

apple.color();  //输出:我是红色的苹果。

Banana banana = (Banana) fruit; //报错:java.lang.ClassCastException

Fruits f1 = new Fruits();

Apple a1 = (Apple) f1;  //报错:java.lang.ClassCastException

为什么Apple apple = (Apple)fruit;没有报错可以转换成功呢?因为apple本身就是Apple对象,所以理所当然可以向下转型为Apple,所以自然也就不能转换成Banana,人可以干出指鹿为马的事情,但是编译器不行,不会指着苹果说是香蕉。

而f1是Fruits对象,它也不能被向下转型为任何子类对象,就好比你买了一个不知名的水果,你只知道它是一种水果,但是你不能直接说这个水果是苹果或者香蕉。

向下转型需要注意的问题

  • 向下转型的前提是父类引用指向的是子类对象,也就是说,向下转型之前,它得先进行过向上转型。
  • 向下转型只能转型为本类对象(苹果是不能变成香蕉的)。

多态的经典案例

简单的多态和转型,相信大家都会,最后来个复杂的,一个经典案例:

class A {
    public String show(D obj) {
        return ("A and D");
    }

    public String show(A obj) {
        return ("A and A");
    }

}

class B extends A{
    public String show(B obj){
        return ("B and B");
    }

    public String show(A obj){
        return ("B and A");
    }
}

class C extends B{

}

class D extends B{

}

public class Demo {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();

        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));
    }
}

/**
输出结果:
    1--A and A
    2--A and A
    3--A and D
    4--B and A
    5--B and A
    6--A and D
    7--B and B
    8--B and B
    9--A and D
*/

结果1、2、3还好理解,从4开始就糊涂了,4为什么不是“B and B”呢?

这里我们先看一句话:当父类对象引用变量引用子类对象时,被引用对象的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在父类中定义过的,也就是说被子类覆盖的方法。这句话对多态进行了一个概括,其实在继承中对象方法的调用存在一个优先级:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

现在来分析一下4,a2.show(b)

  • a2是A类型的引用变量,this就代表了A,但是a2所引用的是B对象(new B()),那么按照上面那句话的意思,a2.show(b)就应该要调用B类中的show(B obj),产生的结果就是”B and B“,但是运行结果明显不是,别忘了上面的话后面还有一句,必须是父类中定义过的方法才行,然而B的父类A中并没有show(B obj),难道上面的话是错误的?其实不是,因为它仍然要按照继承链中调用方法的优先级来确定,所以它才会在A类中找到show(A obj),由于B中重写了该方法,所以才会调用B类中的方法,所以得到的结果是B and A
  • 上面的解释可能有点绕,很多大佬在博客中也是这么写的,现在我来说说自己的理解。A a2 = new B();这行代码进行了向上转型,前面说过向上转型之后,子类单独定义的方法会丢失(不能被调用),那么这个时候a2可以调用的方法就剩下A类中的show(D obj)、show(A obj)以及B类中的show(A obj),那么按照继承链中调用方法的优先级来判断,先到类A中找到show(A obj),由于B类中进行了重写 ,所以调用的是B类中的show(A obj)

那么按照我的理解,来分析下5,a2.show(c)

  • 首先A a2 = new B();进行向上转型,那么,a2能调用的方法还是A类中的show(D obj)、show(A obj)以及B类中的show(A obj),按照继承链中调用方法的优先级,a2是A类型的引用变量,所以继承链方法调用优先级中this.show(O)的this就代表了A,显然A类中的方法不满足这个要求,跳过,所以接下来是super.show(O),A类没有父类(除了Object类),再次跳过,然后是this.show((super)O),C继承于B,B继承于A,所以show(A obj)满足要求,由于a2变量引用的对象类型是B类型,而B类型又重写了该方法,所以最终调用的是B类中的show(A obj),所以最后输出为B and A

能够分析出4和5,那么接下来的就很简单了,看到这篇文章的话,可以自己试着分析下。如果有错误的地方,希望能够指出,大家共同进步!

如果对你有帮助,点击链接,关注一下吧!

相关文章

  • 12.多态中的向上转型和向下转型

    多态中向上转型与向下转型 多态的转型分为向上转型与向下转型两种: A:向上转型:当有子类对象赋值给一个父类引用时,...

  • java多态(重要O!)

    一、多态的语法 关于java语言中的向上转型和向下转型 1、向上转型(upcasting):子 -->父 2、向下...

  • java049多态的转型和优缺点及包

    1.多态中的向上转型和向下转型 引用类型之间的转换: 向上转型:由小到大(子类转换成父类) 向...

  • 多态中的向上转型与向下转型

    在讨论向上转型和向下转型之前,先复习下多态。如果有错误的地方,希望能够指出,大家共同进步! 什么是多态? 多态(P...

  • java的多态性

    1、需有父子类关系,子类通过extends继承父类; 2、java多态性分为向上转型以及向下转型。 向上转型:...

  • Java学习笔记 (一)

    多态性 方法的重载与覆写 对象的多态性①.向上转型:子类对象→父类对象 (自动完成)②.向下转型:父类对象→子类对...

  • 第二十九节:Java基础知识-类,多态,Object,数组和字符

    前言 Java基础知识-类,多态,Object,数组和字符串,回顾,继承,类的多态性,多态,向上转型和向下转型,O...

  • Java面向对象-多态性

    一、多态性 多态性的体现: 对象的多态性: 向上转型:程序会自动完成父类 父类对象 = 子类实例 向下转型:强...

  • 多态基础

    源代码 输出结果 多态相关:向上转型、向下转型、默认无参构造器、多态发生在继承的情况下,覆盖(重写override...

  • Java基础面向对象三大特性之一多态(Polymorphism)

    文章目录 面向对象三大特性之一多态(Polymorphism) 二、向下转型,向上转型 面向对象三大特性之一多态(...

网友评论

      本文标题:多态中的向上转型与向下转型

      本文链接:https://www.haomeiwen.com/subject/vxttqltx.html