精华内容
下载资源
问答
  • 主要介绍了Java向上转型和向下转型实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了 Java 向上转型和向下转型的详解的相关资料,需要的朋友可以参考下
  • 向上转型的作用

    千次阅读 2019-08-10 17:02:10
    一、什么是向上转型 上转型对象不是父类创建的对象,而是子类对象的“简化”状态,它不关心子类新增的功能,只关心子类继承和重写的功能。 当一个类有很多子类时,并且这些子类都重写了父类中的某个方法。 当使用...

    一、什么是向上转型

    上转型对象不是父类创建的对象,而是子类对象的“简化”状态,它不关心子类新增的功能,只关心子类继承和重写的功能。

    当一个类有很多子类时,并且这些子类都重写了父类中的某个方法。

    当使用上转型对象在调用这个方法时就可能具有多种形态。因为不同的子类在重写父类的方法时可能产生不同的行为。也就是说,不同对象的上转型对象调用同一方法可能产生不同的行为。

    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()这个方法。

    那么向上转型到底有什么用呢,到目前为止我们不仅看不到它的好处,反而发现使用了向上转型后反而不能调用子类所特有的方法了。那么向上转型的作用到底是什么呢?

    二、向上转型的作用

    • 传参,当你不知道要传什么类型的参数时,可以直接将参数定义成Object类型的,这样就可以接收任意类型的参数(JAVA中所有的类都继承自java.lang.Object),但使用时要转换回来。
    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();
        }
    }

    如果此处没有向上转型,要实现show每个子类的功能,那么有几个子类就要写多少函数。

    • 接口与抽象编程时使用
    interface a{
        aa();
    }
    b implements a {
        aa(){}
    }
    c implements a {
        aa(){}
    }

    当你不确定要实例化的是b类还是c类,但又一定要返回一个对象并且有aa方法,就可以用类似上面的做法,然后在需要对象时这样使用即可获得对象:   return a a1= new b();
     

    总结 (还是前几章里提到的)

    1.在调用方法的时候,用那个引用就调用那个引用的方法,然后观察子类是否重写,若重写了就调用子类的,否则就调用父类的。

    2.在对象当做参数遇到重载的时候,它会选择与它最接近的类型参数的方法匹配。通俗点说就是,找与自己类型一致的,没有找到则父类,以此类推。

    3.注意子类中没有被重写的父类方法。

     

     

    参考博客:https://zhidao.baidu.com/question/72034787.html

    https://blog.csdn.net/guchenjun789/article/details/81055317

    展开全文
  • Java的向上转型和向下转型利弊

    千次阅读 2018-12-04 18:29:00
    java的向上转型和向下转型 一、向上转型 好处:隐藏了子类型,提高了代码的扩展性。 坏处:只能使用父类的功能,不能使用子类特有功能,功能被限定。 使用场景:不需要面对子类型,通过提高扩展性,或者使用父类的...

    一、向上转型

    1. 好处:隐藏了子类型,提高了代码的扩展性。
    2. 坏处:只能使用父类的功能,不能使用子类特有功能,功能被限定。
    3. 使用场景:不需要面对子类型,通过提高扩展性,或者使用父类的功能即可完成操作,就是使用向上转型。

    二、向下转型

    1. 好处:可以使用子类型的特有功能
    2. 坏处:面对具体的子类型,向下转型具有风险。即容易发生ClassCastException,只要转换类型和对象不匹配就会发生。解决方法:使用关键字instanceof。
    展开全文
  • 主要介绍了简单了解Java多态向上转型相关原理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java向上转型作用的理解

    万次阅读 多人点赞 2018-07-15 18:00:15
    今天看到一道Java的练习题,题目如下 当时对于主函数中 Car car =(Car) new Benz(); 不是很理解,也并不知道有什么意义,因为... 在经过阅读书籍和查看别的博主写的关于向上向下转型的博客后,发现题目中这么...

    今天看到一道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();程序报错
        }
    }
       
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    此时程序运行后输出:这里写图片描述

    但是当我们用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();
        }
    }
    
       
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    上面代码中

        public static void main(String[] args) {
            show(new Benz());
            show(new BMW());
        }
    
        public static void show(Car car) {
            car.run();
            car.speed();
        }
       
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    就体现了向上转型的优点,这也体现了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();
        }
       
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

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


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


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

    转载自:https://blog.csdn.net/TNTZS666/article/details/80273986

    展开全文
  • 一、向上转型和向下转型 向上转型和向下转型是在JAVA继承操作中用到的东西,在讲到转型之前我们需要认识到继承过程中的对象类型转换,这种转换有两个特点: 1.这是继承过程中发生的操作 2.新类是现有类的一种...

    一、向上转型和向下转型

           向上转型和向下转型是在JAVA继承操作中用到的东西,在讲到转型之前我们需要认识到继承过程中的对象类型转换,这种转换有两个特点:

                 1.这是继承过程中发生的操作

                 2.新类是现有类的一种类型。这种说法主要是因为现有类的方法必定存在于新类中,所以通过现有类发送的信息(就是通过创建一个对象进行操作)可以直接通过新类发送。

     二、向上转型

            向上转型:创建一个基类的引用,但是在创建对象的时候是用的导出类的。示意图如下:

                                    

             由图可知:由导出类转型成基类,在继承图上是向上移动的。同时由于是从较专用类型向较通用类型转换,所以是安全的,因为专用类型肯定包含通用类型。

             特点:

                1.把导出类对象直接赋给基类类引用,不用强制转换

                2.引用可以直接使用基类中的方法,但是不能使用导出类的方法

                3.从导出类向上转型,永远不需要知道正在处理的对象的确切类型

                4.在向上转型过程中可能发生类接口中方法丢失

            示例 :

    class Fupcasting{
    	public Fupcasting(String ident) {
    		System.out.println("i am " + ident);
    	}
    	public void count() {
    		
    	}
    }
    public class Upcasting extends Fupcasting{
    	public Upcasting(String ident) {
    		super(ident);
    		// TODO Auto-generated constructor stub
    	}
    	public void add() {}
    	public static void main(String[] args) {
    		String  name = "fatherupcasting";
    		// TODO Auto-generated method stub
    		Fupcasting fupcasting = new Upcasting(name);    //向上转型
    		fupcasting.count();
    		//fupcasting.add();   //使用导出类的方法报错
    	}
    
    }

     三、向下转型

            向下转型可以参照向上转型,二者正好相反。这里使用向下转型的原因是因为上述的向上转型的第三条的关系:从导出类向上转型,永远不需要知道正在处理的对象的确切类型!

            解释如下:

    可知:导出类可以完全代替基类,在使用它们的时候,完全不需要知道关于子类的任何信息。

    这里如果你清楚  引用对象  的概念,你就会明白,当我们在向上转型的时候,你处理的导出类的对象你完全不清楚确切类型,这里的类型可以是 基类,也可以是导出类,也就是这一步:

    Fupcasting fupcasting = new Upcasting(name);  

    你也可以写成这样:

    Fupcasting fupcasting = (Fupcasting)new Upcasting(name);    

    或者这样:

    Fupcasting fupcasting = (Upcasting)new Upcasting(name);    

    这里的   (Upcasting)  和 (Fupcasting)  都声明了我们创建的对象的类型,但是在向上转型的过程中我们是这样做的:

    Fupcasting fupcasting = new Upcasting(name);  

    通过上面的步骤我们知道我们并不清楚这个对象是什么类型的,所以如果在一定的情况下要获取类型信息,就会用到向下转型!

    向下转型示意图:

    借用上面的shape图,如果现在我们知道有一个几何图形,但是我们不清楚它是圆、正方形等,但是它的形状肯定是唯一确定的。

    实例:

    class Fupcasting{
    	public Fupcasting(String ident) {
    		System.out.println("i am " + ident);
    	}
    	public void count() {
    		
    	}
    }
    public class Upcasting extends Fupcasting{
    	public Upcasting(String ident) {
    		super(ident);
    		// TODO Auto-generated constructor stub
    	}
    	public void add() {}
    	public static void main(String[] args) {
    		String  name = "fatherupcasting";
    		// TODO Auto-generated method stub
    	//	Fupcasting fupcasting = (Upcasting)new Upcasting(name);    //向上转型
    	//	fupcasting.count();
    		//fupcasting.add();   //使用导出类的方法报错
    		 Upcasting upcasting = (Upcasting) new Fupcasting(name);   //向下转型
    		 upcasting.add();
    	}
    
    }

    特点:

       1.向下转型可以调用子类类型中所有的成员

       2.父类引用对象指向的是子类对象,那么在向下转型的过程中是安全的,就是编译是不会出错误。但是如果父类引用对象是父类本身,那么在向下转型的过程中是不安全的,编译不会出错,但是运行时会             出现 Java 强制类型转换异常

     

    如果觉得对你有帮助,点个赞再走吧!

    展开全文
  • 什么是向下转型和向上转型
  • Java对象类型向上转型和向下转型

    万次阅读 多人点赞 2019-03-20 19:16:43
    上述代码中,调用run()方法时的参数不仅是Fruit对象,也可以是Apple对象和Orange对象,当传入的是Apple对象和Orange对象时,就会向上转型成Fruit对象,但是调用的show()方法还是Apple对象和Orange对象的show()...
  • 多态的向上转型与向下转型

    千次阅读 2019-04-20 10:25:48
    多态的向上转型与向下转型 多态的转型分为向上转型与向下转型两种: A:向上转型:当有子类对象赋值给一个父类引用时,便是向上转型,多态本身就是向上转型的过程。 使用格式: 父类类型 变量名 = new 子类类型()...
  • 向下转型:Cat cat = (Cat) a,必须要先经过向上转型的变量–再向下转型,此时cat就拥有子类自己定义的特有方法cat.sleep() instanceof用法:a instanceof Cat 这里a必须是经过向上转型后的父类对
  • 对象的向上转型对象

    千次阅读 2019-03-17 17:00:31
    从人的思维方式来看,说“老虎时动物”属于上溯的思维方式,从而衍生出Java中的向上转型对象。 向上转型对象的声明 Animal a = new Tiger(); //或者 Animal a; Tiger b = new Tiger(); a = b; 这时,称对象a是...
  • Java中的向上转型和向下转型

    千次阅读 2018-12-25 15:25:48
    什么是向上转型,向下转型 向上转型就是子类转化成父类,或接口 向下转型就是父类或接口 转化成子类 举个例子:人继承动物类,动物类有一个吃的技能,我们可以说人是动物,这就是向上转型 我们能说动物是人吗?不...
  • 我的处女作《Canvas系列教程》在我的Github上正在连载更新,希望能得到您...其他网上关于向上转型和向下转型并不能完全使读者透彻的了解,因此我决定重写一篇教程来让大家简单理解。 向上转型:将子类转化为父类。...
  • 向上转型和向下转型

    2018-11-30 00:09:08
    向上转型是指将子类的实例赋值给父类类型的变量。 向下转型是指将父类的实例赋值给子类类型的变量。 二、向上转型 1、向上转型后父类的引用所指向的属性是父类的属性。 2、如果子类重写了父类的方法,那么父类引用...
  • 向上转型 向上转型在写代码的过程中经常会用到,它不仅是实现多态的重要机制,也是Java继承体系的精华体现。 向上转型常见的形式是:Person person = new Student();这里的Student类是Person类的子类,我们通过...
  • 简单理解Java中转型问题(向上转型和向下转型) —————————————————————————— 本文内容仅仅为个人的理解,仅供大家参考。如果本文中存在一些错误的地方还请大佬们指出,感激不尽。 ————...
  • * 向上转型:一定是安全的,但是一旦向上转型为父类,就无法调用子类特有的方法。从小范围转向大 * 范围,如从猫转型成动物。 * 描述: * 对象的向上转型就是多态 * 格式: * 父类名称 对象名 = new 子类名称...
  • 刚接触Java,关于多态下向上转型和向下转型,以及父类和子类的调用很混乱,看了一天资料,终于搞明白了 关于多态向上转型和向下转型的要点 一、向上转型后子类不能调用自己的私有属性和私有方法,只能调用父类...
  • java向上转型

    千次阅读 2015-09-30 11:11:52
    向上转型:将子类对象的引用转换为父类对象的引用,这就是向上转型。 ”为新的类提供方法“这并不是继承中最重要的方面,其最重要的是用来表现新类和基类之间的关系。这种关系是”新类是现有类的一种类型“ 也就是is...
  • 子类引用不能指向父类对象 向上转型好处 1.减少重复代码,使代码变得简介 2.提高系统扩展性、 向下转型 向下转型是把父类对象转为子类对象。 向下转型的注意事项 1.向下转型的前提是父类对象指向的是子类对象(需要...
  • 类的向上转型: 父类(包括抽象类)创建的引用类型变量可以调用子类对象 父类引用类型变量应用子类对象时,调用方法只能调用父类中出现过的方法,如果方法被重写,调用的是子类中重写的方法。 普通类示例 父类:...
  • 在Java中有继承关系的类及接口中存在两种动作即向上转型和和向下转型,以更好地实现多态
  • 向上转型与向下转型详解

    千次阅读 2020-03-25 17:21:19
    让我们先来了解一下,怎么用转型。...向上转型: 通过子类对象 (小范围) 实例化父类对象 (大范围) , 这种属于自动转换 Father f = new Son(); 向下转型: 通过父类对象 (大范围) 实例化子类对象 ...
  • 在谈转型之前我们需要了解,关于引用变量的类型和具体实例之间的关系. 举个例子: public class Person { protected String name; protected Integer age; //在构建属性和方法的时候需要注意,访问权限控制符.需要...
  • 向上转型和下转型

    2019-07-22 20:28:56
    1. 基本数据类型向上转型和下转型 就是基本数据类型的自动类型转换(隐式类型转换)和强制类型转换(显示类型转换)。 自动类型转换(隐式类型转换) 概念:低类型自动转换为高类型,叫做向上转型 语法: 数据类型 ...
  • Java多态性(向上转型、向下转型)

    千次阅读 多人点赞 2018-11-05 17:26:44
    文章目录多态1.1 方法的多态性1.2 对象的多态性(抽象类和接口)1.2.1 对象的向上转型1.2.2 对象的向下转型1.2.3 一个向上转型的实例1.3 多态性的总结 多态 在Java中,对于多态的核心表现主要有一下两点: 1.1 方法...
  • 下面来说说抽象对象和接口向上转型的问题:众所周知,抽象类和接口都是不能创建对象的,但是子类的向上转型中,抽象类和接口又可以接受来自子类向上转型创建的对象,由于接口和抽象类的原因一样,所以就以 ...
  • 从 2 个名词开始说起:向上转型(upcasting)、向下转型(downcasting)。 举个例子:有2个类,Father 是父类,Son 类继承自 Father。 第 1 个例子: Father f1 = new Son(); // 这就叫 upcasting (向上转型) // ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 51,694
精华内容 20,677
关键字:

向上转型的好处