精华内容
下载资源
问答
  • 主要介绍了 Java 向上转型和向下转型的详解的相关资料,需要的朋友可以参考下
  • 主要介绍了Java向上转型和向下转型实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 向上转型和向下转型是在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
    基础知识:Java中的继承机制使得一个类可以继承另一个类,继承的类称为子类,被继承的类称为父类。在一个子类被创建的时候,首先会在内存中创建一个父类对象,然后在父类对象外部放上子类独有的属性,两者合起来形成...

    基础知识:Java中的继承机制使得一个类可以继承另一个类,继承的类称为子类,被继承的类称为父类。在一个子类被创建的时候,首先会在内存中创建一个父类对象,然后在父类对象外部放上子类独有的属性,两者合起来形成一个子类的对象,所以子类可以继承父类中所有的属性和方法,包括private修饰的属性和方法,但是子类只是拥有父类private修饰的属性和方法,却不能直接使用它,也就是无法直接访问到它(子类可以通过调用父类的public声明的get方法来获取父类的private属性,但无法访问父类的private方法)。同时子类可以对继承的方法进行重写(@Override),并且新建自己独有的方法。

    1.向上转型:

    假设有一个Fruit类,Fruit类中有一个show()方法,代码如下:

    class Fruit{
    	public void show() {
    		System.out.println("this is a fruit");
    	}
    }

    有一个Apple类继承自Fruit类,该类有自己的方法test(),并且重写了父类的show()方法,代码如下:

    class Apple extends Fruit{
        @Override
        public void show() {
    	System.out.println("this is a apple");
        }
        public void test() {
    	System.out.println("i am a apple");
        }
    }

    实例化Apple类,并新建一个Fruit类的引用变量引用该实例,调用实例的show()方法:

    Fruit fruit = new Apple();
    fruit.show();

    结果为:

    调用实例的test()方法:

    fruit.test();

    结果报错:

    分析:这里用到了向上转型,换言之,就是用父类的引用变量去引用子类的实例,这是允许的。当向上转型之后,父类引用变量可以访问子类中属于父类的属性和方法,但是不能访问子类独有的属性和方法。例子中由于子类重写了父类的show()方法,所以调用的show()方法是子类的show()方法,输出结果为:“this is a apple”,而调用子类的test()方法则会报错。

    2.向下转型

    并不是所有的对象都可以向下转型,只有当这个对象原本就是子类对象通过向上转型得到的时候才能够成功转型。

    实例化Apple类,并新建一个Fruit类的引用变量“fruit”引用该实例,然后新建一个Apple类的引用变量,引用向下转型的“fruit”变量,代码如下:

    Fruit fruit = new Apple();
    Apple apple = (Apple) fruit;

    上述代码是允许的,因为fruit引用的对象原本就是Apple对象向上转型得到的,在对fruit向下转型后得到的还是Apple类的对象,能够被Apple类的引用变量引用。

    假设有一个Orange类继承自Fruit类,代码如下:

    class Orange extends Fruit{
        @Override
        public void show() {
    	System.out.println("this is a Orange");
        }
        public void test() {
    	System.out.println("i am a Orange");
        }
    }

    实例化Apple类,并新建一个Fruit类的引用变量“fruit”引用该实例,然后新建一个Orange类的引用变量,引用向下转型的“fruit”变量,代码如下:

    Fruit fruit = new Apple();
    Orange orange = (Orange) fruit;

    上述代码虽然能够编译成功,但是在运行的时候会报错,因为fruit对象是由Apple对象向上转型得到的,只能够向下转型成Apple对象,不能够向下转型成Orange对象。

    3.转型的好处

    通过向上向下转型肯定是有好处的,比如可以减少编程代码。

    假设在主类中定义了一个run()方法,该方法传入一个Fruit参数,并调用了Fruit对象的show()方法,代码如下:

    public static void run(Fruit fruit) {
    	fruit.show();
       }

    在main()方法中的代码如下:

    public static void main(String[] args) {
        run(new Fruit());
        run(new Apple());
        run(new Orange());
        }

    上述代码中,调用run()方法时的参数不仅是Fruit对象,也可以是Apple对象和Orange对象,当传入的是Apple对象和Orange对象时,就会向上转型成Fruit对象,但是调用的show()方法还是Apple对象和Orange对象的show()方法。这样就不需要在主类中同时重载三个run()方法,减少了代码量。

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

    2016-03-29 13:39:59
    转型是基于继承的。...向下转型父类转换成子类,需要强制转换。 如果父类指向的就是子类,则转型安全;如果不是,会在运行时报错,java.lang.ClassCastException错误。可以使用instanceof来避免出错此类错误

    转型是基于继承的。

    向上转型

    把子类转换成父类,不需要强制转换,则转型后不能访问子类特有的属性和方法,如果子类方法被重写,则根据动态绑定,父类调用子类同名方法时,重写生效,这里可以体现出多态。

    向下转型

    父类转换成子类,需要强制转换。
    如果父类指向的就是子类,则转型安全;如果不是,会在运行时报错,java.lang.ClassCastException错误。可以使用instanceof来避免出错此类错误。

    总结

    • 父类引用可以指向子类对象,子类引用不能指向父类对象。
    • 把子类对象直接赋给父类引用叫upcasting向上转型,向上转型不用强制转型。
      如Father father = new Son();
    • 把指向子类对象的父类引用赋给子类引用叫向下转型(downcasting),要强制转型。
      如father就是一个指向子类对象的父类引用,把father赋给子类引用son 即Son son =(Son)father;
      其中father前面的(Son)必须添加,进行强制转换。
    • upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法,子类方法有效
    • 向上转型的作用,减少重复代码,父类为参数,调有时用子类作为参数,就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象编程思想
    展开全文
  • 主要介绍了Java 转型(向上向下转型)详解及简单实例的相关资料,需要的朋友可以参考下
  • java向上转型和向下转型

    多人点赞 2019-11-13 08:53:52
    我们知道,java这个狗一样的东西的三大特性:继承,封装,多态。 然后继承多态带来的一个比较拗口的问题就是,对象转型问题,我们今天就来扯一下。 首先,规定一下转型的概念,我套用一下黄小斜大神在github上的...

    我们知道,java这个狗一样的东西的三大特性:继承,封装,多态。

    然后继承和多态带来的一个比较拗口的问题就是,对象转型问题,我们今天就来扯一下。

    首先,规定一下转型的概念,我套用一下黄小斜大神在github上的说法,转型,指的是等号左侧引用类型的改变。

    但是此时,有一个概念需要给大家普及一下,我猜测可能很多宝宝们都有这个疑惑,那就是引用(对象的引用)和对象是一个东东吗?

    先说结论:引用是引用,对象是对象,两者不是一个东西。

    先看代码

    Animal animal = new Animal();

    按照没有学习java之前的编程理解,或者说大家刚入门学的C语言的语法理解

    Animal 是变量类型,animal是变量名,new Animal() 代表一个变量值(方法的返回值也可以看做一个变量值)。

    翻译过来就是,我们将new Animal()方法的返回值赋值给Animal类型的变量,变量名为animal。

    但是在java中,我们都说万事万物皆对象,那么再说变量啊就太low了,我们换个说法。

    Animal是类型,animal是引用,new Animal()是一个Animal类的对象。animal是Animal一个类对象的引用。

    需要注意的是,在java中,对象的唯一产出方式就是通过new关键字在堆中创建。

    所以我们接下来就可以说为什么引用不是对象了,我们通过反证法。看代码

            Animal animal;
            animal = new Animal();

    这两行代码和我们之前那句代码没有任何区别。假设animal是一个对象,那么我们为什么还要重新new一遍呢?显然,animal不是对象,“操纵的标识符实际是指向一个对象的引用”,也就是说animal是一个引用,是指向一个可以指向Animal类的对象的引用。真正创建对象的语句是右边的new Animal();

    引用和对象属于多对多的关系。一个引用可以指向多个对象,

            Animal animal;
            animal = new Animal();
            animal = new Animal("乔治");

    一个对象也可以被多个引用指向

            Animal animal1;
            animal1 = new Animal();
            Animal animal2 = animal1;

    概念都说完了,我们开始进入正题,转型

    父类Animal

    package com.study.basicJava.extend.father;
    
    public class Animal {
        public Animal(){
    
        }
        public Animal(String name){
            System.out.println(name);
        }
        public void run(){
            System.out.println("动物都会跑");
        }
    
        public void sing(){
            System.out.println("动物也会叫");
        }
    }

    子类Dog

    package com.study.basicJava.extend.son;
    
    import com.study.basicJava.extend.father.Animal;
    
    public class Dog extends Animal {
        @Override
        public void run(){
            System.out.println("狗是用四条腿跑的");
        }
    
        public void seeHome(){
            System.out.println("狗可以看家");
        }
    }

    代码很简单,我们接下来开始讲向上转型,和向下转型。

    向上转型,父类的引用可以指向子类对象。由范围小---》范围大

    例如:

            //animal是Animal类的引用,new Dog()创建了一个子类对象
            //animal指向了Dog对象
            Animal animal = new Dog();

    或者

     

    这种情况下,虽然animal是个父类对象,但是由于他指向了一个子类对象,因此他可以

    1 使用父类未被子类重写的方法------>animal.sing()------->"动物也会叫"

    2 使用子类重写父类的方法--------->animal.run()---->"狗是用四条腿跑的"

    但是子类独有的方法是不可以使用的--->animal.seeHome()----->编译无法通过。

    向下转型,子类引用指向父类对象,范围大---->范围小

    例如:Dog dog = new Animal();

    这句代码编译时无法通过的,必须有强制类型转换:Dog dog = (Dog)new Animal();

    这样虽然编译通过了,但是运行时会报错,ClassCastException,Animal类型无法被强转为Dog类型

    但是,我们换一种写法

    Animal animal = new Dog()

    Dog dog = animal;

    编译也不通过,但是,加上强制类型转换,Dog dog = (Dog)animal,编译通过,运行无误。

    原因是什么呢?

    重点还是在转型。第一种情况子类的引用直接指向了父类对象,那么子类拥有的方法父类可能并没有,那么引用将无法运行,因为父类对象中并没有这些方法。

    第二种情况,父类引用指向了子类对象,子类对象又指向子类对象,安全无痛,因此没有任何毛病。

    展开全文
  • 多态的向上转型: (1)本质:父类的引用指向了子类对象 (2)语法: 父类类型 引用名 = new 子类类型(); (3)特点(规则):编译类型看左边,运行类型看右边。 可以调用父类中的所有成员(遵守访问权限)(实际...
  • 我的处女作《Canvas系列教程》在我的Github上正在连载更新,希望能得到您...其他网上关于向上转型和向下转型并不能完全使读者透彻的了解,因此我决定重写一篇教程来让大家简单理解。 向上转型:将子类转化为父类。...
  • 有关向上造型和向下造型的核心精髓就是一句话:在创建实例的时候到底是子类的实例还是父类的实例。如果是子类的实例,则就完全可以进行强制类型转换。 向上造型 父类的引用指向子类的对象。实例化成子类,可用方法使...
  • Java向上转型和向下转型利弊

    千次阅读 2018-12-04 18:29:00
    java向上转型和向下转型 一、向上转型 好处:隐藏了子类型,提高了代码的扩展性。 坏处:只能使用父类的功能,不能使用子类特有功能,功能被限定。 使用场景:不需要面对子类型,通过提高扩展性,或者使用父类的...
  • 向上向下转型 定义一个父类Animals包含eat()方法、age初始值为0 然后再定义两个子类:DogCat,都重写了eat()方法age,然后再分别有自己的特有方法狗咆叫bark(),猫睡觉sleep() 向上转型:Animals a = new Cat() ...
  • Java中的向上转型和向下转型

    千次阅读 2018-12-25 15:25:48
    什么是向上转型,向下转型 向上转型就是子类转化成父类,或接口 向下转型就是父类或接口 转化成子类 举个例子:人继承动物类,动物类有一个吃的技能,我们可以说人是动物,这就是向上转型 我们能说动物是人吗?不...
  • 基础知识java继承:Java中的继承机制使得一个类可以继承另一个类,继承的类称为子类,被继承的类称为父类。在一个子类被创建的时候,首先会在内存中创建一个父类对象,然后在父类对象外部放上子类独有的属性,两者合...
  • 刚接触Java,关于多态下向上转型和向下转型,以及父类和子类的调用很混乱,看了一天资料,终于搞明白了 关于多态向上转型和向下转型的要点 一、向上转型后子类不能调用自己的私有属性和私有方法,只能调用父类...
  •  向下转型最主要的目标是支持Java 泛型编程。  例如,我要创建一个List的集合,要将childparent全都装进去,这个时候我我们不能List,List来创建对象,因为还有其他人也要装进去。这个时候我们就用他们一个...
  • 向上转型 我们经常在代码中看到这样的写法 父类型 fat = new 子类型(); 这便是向上转型的实例,即父类引用指向子类对象。 一个完整的实例 package test; /** * @Author: Lemon * @Program: * @...
  • Java向上转型和向下转型的区别

    千次阅读 2020-01-15 13:29:27
    向下转型:通过引用类型强转,恢复了子类的成员变量以及方法。 1.代码实现: 可以发现,父类虽然指向了子类的实例对象,但是并不能调用子类对象的方法,编译器报错。此时我们可以看作被隐藏了,那么怎样才可以把...
  • Java 转型可以分三种情况,分别是:向上转型、向下转型、出错 1、向上转型 是指父类引用指向子类对象。代码如下: Father A = new Son(); // 向上转型 2、向下转型 是指子类引用指向由父类引用所指的子类对象 ...
  • 相信学Java的人在学习的时候都了解过向上转型和向下转型,但是很多人有的时候都分不清哪个是向上转型哪个是向下转型,因此本文给大家简单介绍一下,希望能对大家有帮助。。。 向上转型:父类引用指向子类对象。。 ...
  • Java向上向下转型的作用 一、向上转型 这个是我们平时用的最多的,比如我们要定义某一个方法的时候,经常使用一个抽象类(父类)或者接口作为参数把他们的子类传递过去,在传递的过程中,这个子类默认就是进行向上...
  • java向上转型向下转型

    2012-09-04 10:44:18
    java转型
  • java对象转型(向上转型和向下转型)向下转型和向上转型是什么意思向上转型和向下转型的基本公式: 向下转型和向上转型是什么意思 基本数据类型,转换可以通过隐性和显性(强制)类型转换,例如float类型转成int类型...
  • 熬夜整理的关于Java向上和向下转型的例子,非常的通俗易懂哦~~~~ 一.向上转型 [java] view plain copy package com.sheepmu;   class Animal   {   public void eat()...
  • 学习向上转型和向下转型怎么用没多难,但是为什么那样用,我搞了很多次没弄明白。没弄明白的原因是平时学习时之看例子,而例子一般都比较简单,没有对象之间的调用,一般就是一个对象调用自己的方法。 首先看下怎么...
  • 1、对象的向上转型,就是父类引用,指向子类对象。 2、对象的向上转型,其实就是多态的写法; 格式:父类名称 对象名 = new 子类名称(); 含义: 右侧创建一个子类对象,把他当做父类来看待使用。 注意事项: 向上...
  • Java对象类型转换:向上转型和向下转型 将一个类型强制转换成另一个类型的过程被称为类型转换。本节所说的对象类型转换,是指存在继承关系的对象,不是任意类型的对象。当对不存在继承关系的对象进行强制类型转换时...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,379
精华内容 10,551
关键字:

java向上和向下转型

java 订阅