向上转型与向下转型（超详细）

已于 2022-08-21 18:41:29 修改
阅读量7.3k 收藏 63
点赞数 18
分类专栏： JavaSE 文章标签： java 开发语言
于 2022-08-21 18:25:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Smart_auspicious/article/details/126449543
版权

本文利用代码例子解释向上转型与向下转型，文末有举例整合原代码。

首先，我们要知道：转型发生在继承后，也就是父类子类存在的前提下。其次，我们要清楚：向下转型的前提是已经发生了向上转型，向下转型是再次转回来而已。最后，我们要明白：向上转型和向下转型都有三种方法：直接赋值、作为参数和作为返回值类型。另外，我们要注意：向下转型要用到强制类型转换，从而完成接收。

定义三个类：Animals 类、NiuMa 类、A 类：

class Animals{  //Animals类，作为父类
    public void eat1(){
        System.out.println("几乎都是肉食动物");
    }
}

class NiuMa extends Animals{   //NiuMa类：作为子类
    public void eat2(){
        System.out.println("杂食动物");
    }
    public void sleep(){
        System.out.println("都要睡觉。");
    }
}

class A{    //A类：作为参数和返回类型要用到。
    public void func1(Animals animals){
        animals.eat1();
        System.out.println("父类形参");
    }
    public void func3(NiuMa niuMa){
        niuMa.sleep();
        System.out.println("子类形参");
    }

    public NiuMa func2(){
        System.out.println("此时返回值类型与public后的引用类型一致");
        return new NiuMa();
    }   
    public Animals func4(){
        System.out.println("此时返回值类型与public后的引用类型不一致！");
        return new NiuMa();
    }
    public Animals func5(){
        System.out.println("此时返回值类型与public后的引用类型一致");
        return new Animals();
    }
    public NiuMa func6(){
        System.out.println("此时返回值类型与public后的引用类型不一致！");
        return (NiuMa)new Animals();
    }
}

Animals 类：作为父类，具有公共方法 eat1() 。

NiuMa 类：作为子类，具有子类独有方法 sleep() 。

A 类：作为其他类，要借助该类实现参数类型和返回值类型的转型。

向上转型：

一、直接赋值法：

class Text{
   public static void main(String[] args) {
         Animals people1 = new NiuMa();
         people1.eat1();//调用继承后公共部分的方法，没重写调用没重写的，重写了调用重写后的。
   }
}

父类引用子类对象：Fu dui1 = new Zi();

可用该对象调用继承后公共部分的方法，若该方法被子类重写，则调用重写后的方法。

二、作为参数法：

class Text{
   public static void main(String[] args) {
        NiuMa niuma1 = new NiuMa();
        A a1 = new A();
        a1.func1(niuma1);
   }
}

形参为父类，实参为子类。

在方法中实现向上转型，即在 func 方法中已经完成转型任务，完成调用其他方法的实现。

三、作为返回值类型法：

class Text{
   public static void main(String[] args) {
        //返回值类型法向上转型：

        //利用func2():public后面为子类，返回值类型为子类
        A a1 = new A();
        //用引用类型直接接收：
        NiuMa niuma1 = a1.func2();//正常接收。
        Animals animals1 = a1.func2();//发生了向上转型
        //new对象进行接收：
        NiuMa niuma2 = new NiuMa();
        Animals animals2 = new Animals();
        niuma2 = a1.func2(); //正常接收
        animals2 = a1.func2();//发生了向上转型

        //利用finc4():public后面为父类，返回值类型为子类
        A a2 = new A();
        //用引用类型直接接收：
        NiuMa niuma3 = (NiuMa) a2.func4();//相当于发生了一次向下转型
        Animals animals3 = a2.func4();//正常接收。
        //new对象进行接收：
        NiuMa niuma4 = new NiuMa();
        Animals animals4 = new Animals();
        niuma4 = (NiuMa) a2.func4(); //相当于又发生了一次向下转型。
        animals4 = a2.func4();//正常接收

        //结论：当public后面为父类，返回值为子类时，实际返回值为父类类型。

   }
}

此块代码主要看利用 func2() 的，因为返回值类型参考的是 public 后为父类还是子类。

父类引用，接收返回类型为子类的方法，实现向上转型。

向下转型：

一、直接赋值法：

class Text{
   public static void main(String[] args) {
        Animals people2 = new NiuMa();//要先发生一次向上转型
        NiuMa people3 = (NiuMa) people2; //将people2强制类型转换成NiuMa类，用people3接收
        people1.eat1();
        people3.sleep();
   }
}

要先发生向上转换：Fu dui2 = new Zi();

向下转换：Zi dui3 = (ZI) dui3;

二、作为参数法：

class Text{
   public static void main(String[] args) {
        Animals animals1 = new NiuMa();//先发生强制类型转换
        A a2 = new A();
        a2.func3((NiuMa) animals1);
   }
}

形参为子类，实参为父类。

在方法中实现向下转型，即在 func 方法中已经完成转型任务，完成调用其他方法的实现。

传参时要进行强制类型转换。

三、作为返回值类型法：

public Text{
    public static void main(String[] args) {
        //返回值类型法向下转型：

        //利用func5():public后面为父类，返回值类型为父类。
        A a1 = new A();
        //用引用类型直接接收：
        NiuMa niuma1 = (NiuMa) a1.func5();//发生了向下转型
        Animals animals1 = a1.func5();//正常接收
        //new对象进行接收：
        NiuMa niuma2 = new NiuMa();
        Animals animals2 = new Animals();
        niuma2 = (NiuMa) a1.func5();//发生了向下转型
        animals2 = a1.func5();//正常接收

        //利用func6():public后面为子类，返回值类型为父类。
        A a2 = new A();
        //用引用类型直接接收：
        NiuMa niuma3 = a2.func6();//正常接收
        Animals animals3 = a2.func6();//相当于向上转型
        //new对象进行接收：
        NiuMa niuma4 = new NiuMa();
        Animals animals4 = new Animals();
        niuma4 = a2.func6(); //正常接收
        animals4 = a2.func6();//相当于向上转型

        //小结：当public后面为子类，返回值类型为父类的时候，返回值类型为子类。
    }
}

此块代码主要看利用 func5() 的，因为返回值类型参考的是 public 后为父类还是子类。

子类引用，接收返回类型为父类的方法，实现向上转型，要注意进行强制类型转换。

注意点：

一、以下为错误代码：

class Text{
   public static void main(String[] args) {
        //⭐错误代码：
        Animals people = new Animals();
        A a = new A();
        a.func3(people);
        //形参只能向下兼容，不能向上兼容。向下兼容的时候传入子类则会发生向上转型。
   }
}

此时代码直接会报错：

因为该代码与是否发生向上转型或向下转型无关。而向下转型的本质是已经发生过向上转型，通过强制类型转换从而回来罢了，但是该处错误直接类型不匹配。

由此我们也可以得出一个结论：

形参只能向下兼容，不能向上兼容。向下兼容的时候传入子类则会发生向上转型。

二、关于返回值类型同方法上下不匹配：

在 func4() 与 func6() 中，public 后的引用类型与返回值类型不匹配，但在主函数中用某引用类型去接收该返回值的时候，一定要用 pubic 后的引用类型。

三、为什么会发生向上转型和向下转型？

向上转型是为了调用父类中的方法，向下转型是为了使用完后转回子类，以此才能调用父类中没有的方法。

总结：

向上转型：自动转型，父类引用子类对象。for调父类方法。

向下转型：强制类型转换，本质上就是子类已经发生了向上转型，再次转回来而已。for调父类中没有的子类方法。

以下为整合代码：

放入 Idea 里分别把 main 方法放开运行理解更深刻：

class Animals{
    public void eat1(){
        System.out.println("几乎都是肉食动物");
    }
}
class NiuMa extends Animals{
    public void eat2(){
        System.out.println("杂食动物");
    }
    public void sleep(){
        System.out.println("都要睡觉。");
    }
}
class A{
    public void func1(Animals animals){
        animals.eat1();
        System.out.println("父类形参");
    }
    public void func3(NiuMa niuMa){
        niuMa.sleep();
        System.out.println("子类形参");
    }

    public NiuMa func2(){
        System.out.println("此时返回值类型与public后的引用类型一致");
        return new NiuMa();
    }
    public Animals func4(){
        System.out.println("此时返回值类型与public后的引用类型不一致！");
        return new NiuMa();
    }

    public Animals func5(){
        System.out.println("此时返回值类型与public后的引用类型一致");
        return new Animals();
    }
    public NiuMa func6(){
        System.out.println("此时返回值类型与public后的引用类型不一致！");
        return (NiuMa)new Animals();
    }

}
public class ZhuAn {
    public static void main4(String[] args) {//主要为向下转型。
        //返回值类型法向下转型：

        //利用func5():public后面为父类，返回值类型为父类。
        A a1 = new A();
        //用引用类型直接接收：
        NiuMa niuma1 = (NiuMa) a1.func5();//发生了向下转型
        Animals animals1 = a1.func5();//正常接收
        //new对象进行接收：
        NiuMa niuma2 = new NiuMa();
        Animals animals2 = new Animals();
        niuma2 = (NiuMa) a1.func5();//发生了向下转型
        animals2 = a1.func5();//正常接收

        //利用func6():public后面为子类，返回值类型为父类。
        A a2 = new A();
        //用引用类型直接接收：
        NiuMa niuma3 = a2.func6();//正常接收
        Animals animals3 = a2.func6();//相当于向上转型
        //new对象进行接收：
        NiuMa niuma4 = new NiuMa();
        Animals animals4 = new Animals();
        niuma4 = a2.func6(); //正常接收
        animals4 = a2.func6();//相当于向上转型

        //小结：当public后面为子类，返回值类型为父类的时候，返回值类型为子类。
    }
    public static void main3(String[] args) {//主要为向上转型：
        //返回值类型法向上转型：

        //利用func2():public后面为子类，返回值类型为子类
        A a1 = new A();
        //用引用类型直接接收：
        NiuMa niuma1 = a1.func2();//正常接收。
        Animals animals1 = a1.func2();//发生了向上转型
        //new对象进行接收：
        NiuMa niuma2 = new NiuMa();
        Animals animals2 = new Animals();
        niuma2 = a1.func2(); //正常接收
        animals2 = a1.func2();//发生了向上转型

        //利用finc4():public后面为父类，返回值类型为子类
        A a2 = new A();
        //用引用类型直接接收：
        NiuMa niuma3 = (NiuMa) a2.func4();//相当于发生了一次向下转型
        Animals animals3 = a2.func4();//正常接收。
        //new对象进行接收：
        NiuMa niuma4 = new NiuMa();
        Animals animals4 = new Animals();
        niuma4 = (NiuMa) a2.func4(); //相当于又发生了一次向下转型。
        animals4 = a2.func4();//正常接收

        //结论：当public后面为父类，返回值为子类时，实际返回值为父类类型。

    }

    public static void main2(String[] args) {
        //传参法：在方法内实现向上转型，在方法内调用方法。

        //向上转型：
        NiuMa niuma1 = new NiuMa();
        A a1 = new A();
        a1.func1(niuma1);

        //向下转型：
        Animals animals1 = new NiuMa();//先发生强制类型转换
        A a2 = new A();
        a2.func3((NiuMa) animals1);

        //⭐错误代码：
        //Animals people = new Animals();
        //A a = new A();
        //a.func3(people);
        //形参只能向下兼容，不能向上兼容。向下兼容的时候传入子类则会发生向上转型。
    }

    public static void main1(String[] args) {
        //直接赋值法

        //向上转型
        Animals people1 = new NiuMa();
        people1.eat1();//调用继承后公共部分的方法，没重写调用没重写的，重写了调用重写后的。

        //向下转型
        Animals people2 = new NiuMa();//要先发生一次向上转型
        NiuMa people3 = (NiuMa) people2; //将people2强制类型转换成NiuMa类，用people3接收
        people1.eat1();
        people3.sleep();
    }
}

Smart_auspicious
关注
  • 18
    点赞
  • 踩
  • 63
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
向上（向下）转型的理解与应用
m0_62084473的博客
12-02 967
向上（向下）转型的理解与应用
向上转型和向下转型、自动类型转换和强制类型转换[详解]
weixin_45233980的博客
03-08 2358
float f=(float)12.3;但整数类型为了方便编写,允许右边的字面量没有超出左边的数据类型的范围不需要强制转换;超出范围则还是需要强制转换,如byte b2=(byte)128;
9.什么是向上转型？什么是向下转型？
cxrlover的博客
12-07 3320
向上转型： 一般来说就是： 父类引用指向子类对象，是多态实现的一个基础。也就是说，父类引用可以自动地包装子类对象。例如：Student类 继承了 Person 类 Person person = new Student(); 向下转型： 与向上转型正好相反，就是子类引用指向父类对象。但这种转型可能存在转型失败地风险，因为父类地范围更广，如果不确定父类对象就是该子类的对象，不推荐使用向下转型。 Teacher 类 也继承了 Person 类，这是转型就会出现错误。 Person person = new S
向下转型（通俗易懂）
qq_42732184的博客
04-25 1万+
向下转型 与向上转型相对应的就是向下转型了。向下转型是把父类对象转为子类对象。(请注意！这里是有坑的。) 案例驱动 先看一个例子： Animal a = new Cat(); Cat c = (Cat) a; c.eat(); //输出 我吃鱼 Dog d = (Dog) a; d.eat(); // 报错 ： java.lang.ClassCastException Animal a1 = new Animal(); Cat c1 = (Cat) a1; c1.eat(); // 报错 ： java.l
[JAVA]向上转型与向下转型
weixin_67719939的博客
03-25 344
java向上转型，向下转型的使用和事例，instanceof关键字
C++ 向上转型和向下转型的含义以及使用场景
竹剑单
06-04 2705
向上转型 派生类对象转型为基类对象（包括指针和对象），直接转化由编译器自动完成，不用cast，并且是绝对安全的。 内存里面：基类对象相当于只是换了个地址。换成了派生类对象中存储基类成员的内存地址。但是派生类对象中有的，基类没有的那些变量仍然留在了内存中。（保留了再次从基类转换成派生类的可能性） 向下转型 不能在对象之间转换。只能在指针和指针之间、基类左值和派生类引用之间转换。 危险是什么意思？应该是指把基类对象的地址给了派生类对象（向下转换）。派生类对象如果拥有自己独有，而基类没有的成员变量，就是危险的。因
Java 向上转型和向下转型的详解
08-30
"Java 向上转型和向下转型的详解" Java 向上转型和向下转型是面向对象编程语言中的一个重要概念，它们都是继承机制的基础上进行转型的。向上转型是将子类对象转换为父类类型的过程，而向下转型是将父类对象转换...
Java向上转型和向下转型实例解析
08-25
"Java向上转型和向下转型实例解析" 在Java中，向上转型和向下转型是两个非常重要的概念，它们都是基于继承机制的。向上转型是指子类对象转换为父类或接口，而向下转型是指父类对象转换为子类。了解向上转型和向下...
Java 转型(向上或向下转型)详解及简单实例
08-31
本文将深入探讨Java中的向上转型和向下转型，同时提供简单的实例来帮助理解这些概念。 首先，让我们了解一下向上转型。向上转型（Upcasting）是指将子类对象赋值给父类引用。在Java中，这是自动完成的，因为子类...
学习Java之如何正确地向上转型与向下转型.rar
07-10
这种继承关系使得子类能够具备父类的特性，同时也允许在代码中进行类型转换，即向上转型和向下转型。本文将深入探讨这两种转型方式以及如何正确使用它们。 **向上转型（Upcasting）** 向上转型是指将子类对象赋值给...
java向上转型向下转型
09-04
Java 向上转型与向下转型 Java 转型是 Java 编程中的一种非常重要的概念，主要包括向上转型和向下转型两种。向上转型是指将子类对象转换为父类对象，而向下转型是指将父类对象转换为子类对象。 向上转型...
Java向上转型和向下转型的通俗简单理解以及使用用途
苏一恒
12-06 1万+
我的处女作《Canvas系列教程》在我的Github上正在连载更新，希望能得到您的关注和支持，让我有更多的动力进行创作。 教程介绍、教程目录等能在README里查阅。 传送门：https://github.com/827652549/CanvasStudy 其他网上关于向上转型和向下转型并不能完全使读者透彻的了解，因此我决定重写一篇教程来让大家简单理解。 向上转型：将子类转化为父类。...
理解“向上转型”和“向下转型”的简单例子
PaperBack
02-19 5250
import static net.mindview.util.Print.*; class Useful{ public void f(){print("Useful:f()");} public void g(){print("Useful:g()");} } class MoreUseful extends Useful{ public void f(){prin...
Java 向上、向下转型详解
鱼丸丶粗面
09-14 575
文章目录1、概述1.1 场景1.2 结论1.3 思维导图2、向上转型2.1 使用方法2.2 意义3、向下转型3.1 使用方法 1、概述 1.1 场景 转型，是 Java 多态的特性之一（继承、重写、转型），也如日常工作常见的编码，故 有必要明确其知识点。 1.2 结论 向上转型： 子类 转 父类，属于 自动转换 // Father s = new Son(); 意义： 实现 "参数统...
向上转型和向下转型，动态转换、和静态转换详解
xzh_blue的专栏
06-08 1193
子类转换为父类：向上转型，使用dynamic_cast(expression)，这种转换相对来说比较安全不会有数据的丢失； 父类转换为子类：向下转型，可以使用强制转换，这种转换时不安全的，会导致数据的丢失，原因是父类的指针或者引用的内存中可能不包含子类的成员的内存。 动态转换和静态转换，dynamic_cast(expression),static_cast(expression)，表示的是将...
重新认识java（五） ---- 面向对象之多态（向上转型与向下转型）
热门推荐
mystery的博客
01-26 6万+
多态，大概每个人都知道。但是，又有几个人真的理解什么是多态、多态有哪些细节呢？如果你看到这篇文章的名字，脑海中对多态没有一个清晰的概念，不妨点进来看看，也许会有收获。
Java向上转型和向下转型（附详细例子）
毛毛虫的小哈
08-01 3万+
Java向上转型和向下转型（附详细例子） 熬夜整理的关于Java向上和向下转型的例子，非常的通俗易懂哦~~~~ 一.向上转型 package com.sheepmu; class Animal { public void eat() { System.out.println("父类的 eating..."); } } class Bird extends Animal {
向上转型 向下转型
小波的博客
07-12 5101
如父类Animal，子类Cat,Dog。其中Animal可以是类也可以是接口，Cat和Dog是继承或实现Animal的子类。Animal animal = new Cat();声明的是父类，实际指向的是子类的一个对象。理解多态，首先要知道“向上转型”。我定义了一个子类Cat，它继承了Animal类，那么后者就是前者是父类。我可以通过 Cat c = new Cat(); 实例化一个Cat的对象，这...
java的多态（向上转型、向下转型）
ldshx3的博客
08-27 1万+
java的多态（向上转型、向下转型）在我的理解：java向上和向下转型可以看成是类型的转换。public class Person { public void eat(){ System.out.println("Person eatting..."); } public void sleep() { System.out.println("P
ssm中向上转型和向下转型
最新发布
03-27
在SSM（Spring+SpringMVC+MyBatis）框架中，向上转型和向下转型是面向对象编程中的两个重要概念。 1. 向上转型（Upcasting）： 向上转型是指将一个子类对象赋值给父类引用变量的过程。通过向上转型，子类对象可以被当作父类对象来使用，可以调用父类中定义的方法和属性。这种转型是安全的，不会导致数据丢失或类型错误。 2. 向下转型（Downcasting）： 向下转型是指将一个父类引用变量强制转换为子类对象的过程。通过向下转型，可以访问子类特有的方法和属性。但是需要注意的是，向下转型需要满足两个条件：一是原始对象本身就是子类对象；二是在进行向上转型后，再进行向下转型。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值