精华内容
下载资源
问答
  • 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

    展开全文
  • 向上转型作用

    千次阅读 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

    展开全文
  • 向上转型作用于泛型

    2017-08-11 16:19:34
    可将子类对象放入保存父类对象的容器内。 package com.htxx.action.business; import java.util.ArrayList; import java.util.List; ...public class Cycle { ... System.out.println("ride");... public s

    可将子类对象放入保存父类对象的容器内。

    package com.htxx.action.business;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class Cycle {
       void ride(Cycle c){
    	   System.out.println("ride");
       }
       public static void main(String[] args) {
    	   List<Cycle> list=new ArrayList<Cycle>();
    	   list.add(new Unicycle());
    	   list.add(new Bicycle());
    	   list.add(new Tricycle());
    	   for(Cycle c:list){
    		   System.out.println(c.toString());
    	   }
    
    	   
    }
    }
    class Unicycle extends Cycle{
    	
    }
    class Bicycle extends Cycle{
    	
    }
    class Tricycle extends Cycle{
    	
    }


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

    千次阅读 多人点赞 2018-05-11 11:04:58
    今天看到一道Java的练习题,题目如下 当时对于主函数中 ... 在经过阅读书籍和查看别的博主写的关于向上向下转型的博客后,发现题目中这么写完全就是为了出题用,它和仅仅写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();程序报错
        }
    }

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

    但是当我们用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的抽象编程思想,但是也出现了上面提到的子类无法调用其独有的方法,这要怎么解决呢?所以就有了与之对应的向下转型,弥补了向上转型所带来的缺陷。关于向下转型我会在下一次的博客中给出例子。希望对大家有帮助。

    展开全文
  • 多态的好处和弊端以及对象的向上转型和向下转型 多态的好处 提高了代码的可维护性(继承保证) 2.提高了代码的扩展性(由多态保证) // An highlighted block var foo = 'bar';
  • 主要介绍了简单了解Java多态向上转型相关原理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java向上转型作用

    2019-08-22 17:38:32
    java向上转型作用 关于向上转型作用,我们从一段代码引入: public class Animal { String name = "我是动物"; static int age = 20; public void eat() { System.out.println("动物可以吃饭"); } ...
  • 一、向上转型和向下转型 向上转型和向下转型是在JAVA继承操作中用到的东西,在讲到转型之前我们需要认识到继承过程中的对象类型转换,这种转换有两个特点: 1.这是继承过程中发生的操作 2.新类是现有类的一种...
  • 什么是向下转型和向上转型
  • Java对象类型向上转型和向下转型

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

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

    千次阅读 多人点赞 2017-07-20 15:43:38
    Java向上转型和向下转型
  • 我的处女作《Canvas系列教程》在我的Github上正在连载更新,希望能得到您...其他网上关于向上转型和向下转型并不能完全使读者透彻的了解,因此我决定重写一篇教程来让大家简单理解。 向上转型:将子类转化为父类。...
  • java向上转型

    千次阅读 2015-09-30 11:11:52
    向上转型:将子类对象的引用转换为父类对象的引用,这就是向上转型。 ”为新的类提供方法“这并不是继承中最重要的方面,其最重要的是用来表现新类和基类之间的关系。这种关系是”新类是现有类的一种类型“ 也就是is...
  • 多态的向上转型与向下转型

    千次阅读 2019-04-20 10:25:48
    多态的向上转型与向下转型 多态的转型分为向上转型与向下转型两种: A:向上转型:当有子类对象赋值给一个父类引用时,便是向上转型,多态本身就是向上转型的过程。 使用格式: 父类类型 变量名 = new 子类类型()...
  • 对象的向上转型对象

    千次阅读 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
    什么是向上转型,向下转型 向上转型就是子类转化成父类,或接口 向下转型就是父类或接口 转化成子类 举个例子:人继承动物类,动物类有一个吃的技能,我们可以说人是动物,这就是向上转型 我们能说动物是人吗?不...
  • 向上转型和向下转型

    2018-11-30 00:09:08
    向上转型是指将子类的实例赋值给父类类型的变量。 向下转型是指将父类的实例赋值给子类类型的变量。 二、向上转型 1、向上转型后父类的引用所指向的属性是父类的属性。 2、如果子类重写了父类的方法,那么父类引用...
  • 下面来说说抽象对象和接口向上转型的问题:众所周知,抽象类和接口都是不能创建对象的,但是子类的向上转型中,抽象类和接口又可以接受来自子类向上转型创建的对象,由于接口和抽象类的原因一样,所以就以 ...
  • 向上转型 向上转型在写代码的过程中经常会用到,它不仅是实现多态的重要机制,也是Java继承体系的精华体现。 向上转型常见的形式是:Person person = new Student();这里的Student类是Person类的子类,我们通过...
  • 简单理解Java中转型问题(向上转型和向下转型) —————————————————————————— 本文内容仅仅为个人的理解,仅供大家参考。如果本文中存在一些错误的地方还请大佬们指出,感激不尽。 ————...
  • java中向上转型的意义

    千次阅读 2018-07-06 10:35:45
    向上转型的意义:程序开始的时候确定有一个father型对象,但是要根据用户的选择来决定他要被实例化成哪种类型的。但如果你要分开来声明的话,那你就因为不确定性必须要声明两个变量,分别来等待实例化。 就是实例化...
  • 刚接触Java,关于多态下向上转型和向下转型,以及父类和子类的调用很混乱,看了一天资料,终于搞明白了 关于多态向上转型和向下转型的要点 一、向上转型后子类不能调用自己的私有属性和私有方法,只能调用父类...
  • 这种多态通过函数的重写以及向上转型来实现,我们上面代码中的例子就是一个完整的重写式多态。我们接下来讲的所有多态都是重写式多态,因为它才是面向对象编程中真正的多态。 动态绑定技术涉及到jvm,暂时不讲...

空空如也

空空如也

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

向上转型的作用