精华内容
下载资源
问答
  • 向上转型和向下转型的区别
    千次阅读
    2018-11-30 00:09:08

    一、概念
    向上转型是指将子类的实例赋值给父类类型的变量。
    向下转型是指将父类的实例赋值给子类类型的变量。
    二、向上转型
    1、向上转型后父类的引用所指向的属性是父类的属性。
    2、如果子类重写了父类的方法,那么父类引用指向的或者调用的方法是子类的方法,这个叫动态绑定(实现多态)。
    3、父类引用不能调用子类自己的方法。
    4、向上转型会丢失子类的新增方法,同时会保留子类重写的方法。
    三、向下转型
    1、编译时需要强制类型转换,father前面的必须添加(Son)。
    2、运行时会出现java.lang.ClassCastException错误,可使用instanceof来避免出错此类错误。
    3、向下转型可以得到子类的所有方法(包含父类的方法)。

    更多相关内容
  • 主要介绍了 Java 向上转型和向下转型的详解的相关资料,需要的朋友可以参考下
  • 主要介绍了Java向上转型和向下转型实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 父子对象之间的转换分为了向上转型和向下转型,它们区别如下: 向上转型:通过子类对象(小范围)实例化父类对象(大范围),这种属于自动转换 失去了子类新增的方法,只能调用父类里面已经有的方法 向下转型:通过父类...

    父子对象之间的转换分为了向上转型和向下转型,它们区别如下:

    向上转型:通过子类对象(小范围)实例化父类对象(大范围),这种属于自动转换

    失去了子类新增的方法,只能调用父类里面已经有的方法

    向下转型:通过父类对象(大范围)实例化子类对象(小范围) .这种属于强制转换

    在Java中.向下转型则是为了.通过父类强制转换为子类.从而来调用子类独有的方法,为了保证向下转型的顺利完成。在Java中提供了一个关键字instanceof ,通过instanceof可以判断某对象是否是某类的实例,如果是则返回true, 否则为false 

    参考视频:69、向上转型和向下转型_哔哩哔哩_bilibili

    展开全文
  • 1 向上转型(子类转型成父类)举例:package a.b;public class A {public void a1() {System.out.println("Superclass");}}A的子类B:package a.b;public class B extends A {public void a1() {System.out.println(...

    1 向上转型(子类转型成父类)

    举例:

    package a.b;

    public class A {

    public void a1() {

    System.out.println("Superclass");

    }

    }

    A的子类B:

    package a.b;

    public class B extends A {

    public void a1() {

    System.out.println("Childrenclass"); //覆盖父类方法

    }

    public void b1(){} //B类定义了自己的新方法

    }

    C类:

    package a.b;

    public class C {

    public static void main(String[] args) {

    A a = new B(); //向上转型

    a.a1();

    }

    }

    如果运行C,输出的是Superclass 还是Childrenclass?不是你原来预期的Superclass,而是Childrenclass。这是因为a实际上指向的是一个子类对象。当然,你不用担心,Java虚拟机会自动准确地识别出究竟该调用哪个具体的方法。不过,由于向上转型,a对象会遗失和父类不同的方法,例如b1()。有人可能会提出疑问:这不是多此一举吗?我们完全可以这样写:

    B a = new B();

    a.a1();

    确实如此!但这样就丧失了面向抽象的编程特色,降低了可扩展性。其实,不仅仅如此,向上转型还可以减轻编程工作量。来看下面的显示器类Monitor:

    package a.b;

    public class Monitor{

    public void displayText() {}

    public void displayGraphics() {}

    }

    液晶显示器类LCDMonitor是Monitor的子类:

    package a.b;

    public class LCDMonitor extends Monitor {

    public void displayText() {

    System.out.println("LCD display text");

    }

    public void displayGraphics() {

    System.out.println("LCD display graphics");

    }

    }

    阴极射线管显示器类CRTMonitor自然也是Monitor的子类:

    package a.b;

    public class CRTMonitor extends Monitor {

    public void displayText() {

    System.out.println("CRT display text");

    }

    public void displayGraphics() {

    System.out.println("CRT display graphics");

    }

    }

    等离子显示器PlasmaMonitor也是Monitor的子类:

    package a.b;

    public class PlasmaMonitor extends Monitor {

    public void displayText() {

    System.out.println("Plasma display text");

    }

    public void displayGraphics() {

    System.out.println("Plasma display graphics");

    }

    }

    现在有一个MyMonitor类。假设没有向上转型,MyMonitor类代码如下:

    package a.b;

    public class MyMonitor {

    public static void main(String[] args) {

    run(new LCDMonitor());

    run(new CRTMonitor());

    run(new PlasmaMonitor());

    }

    public static void run(LCDMonitor monitor) {

    monitor.displayText();

    monitor.displayGraphics();

    }

    public static void run(CRTMonitor monitor) {

    monitor.displayText();

    monitor.displayGraphics();

    }

    public static void run(PlasmaMonitor monitor) {

    monitor.displayText();

    monitor.displayGraphics();

    }

    }

    可能你已经意识到上述代码有很多重复代码,而且也不易维护。有了向上转型,代码可以更为简洁:

    package a.b;

    public class MyMonitor {

    public static void main(String[] args) {

    run(new LCDMonitor()); //向上转型

    run(new CRTMonitor()); //向上转型

    run(new PlasmaMonitor()); //向上转型

    }

    public static void run(Monitor monitor) { //父类实例作为参数

    monitor.displayText();

    monitor.displayGraphics();

    }

    }

    我们也可以采用接口的方式,例如:

    package a.b;

    public interface Monitor {

    abstract void displayText();

    abstract void displayGraphics();

    }

    将液晶显示器类LCDMonitor稍作修改:

    package a.b;

    public class LCDMonitor implements Monitor {

    public void displayText() {

    System.out.println("LCD display text");

    }

    public void displayGraphics() {

    System.out.println("LCD display graphics");

    }

    }

    2 向下转型(父类转型成子类)

    A类:

    package a.b;

    public class A {

    void aMthod() {

    System.out.println("A method");

    }

    }

    A的子类B:

    package a.b;

    public class B extends A {

    void bMethod1() {

    System.out.println("B method 1");

    }

    void bMethod2() {

    System.out.println("B method 2");

    }

    }

    C类:

    package a.b;

    public class C {

    public static void main(String[] args) {

    A a1 = new B(); // 向上转型

    a1.aMthod(); // 调用父类aMthod(),a1遗失B类方法bMethod1()、bMethod2()

    B b1 = (B) a1; // 向下转型,编译无错误,运行时无错误

    b1.aMthod(); // 调用父类A方法

    b1.bMethod1(); // 调用B类方法

    b1.bMethod2(); // 调用B类方法

    A a2 = new A();

    B b2 = (B) a2; // 向下转型,编译无错误,运行时将出错

    b2.aMthod();

    b2.bMethod1();

    b2.bMethod2();

    }

    }

    从上面的代码我们可以得出这样一个结论:向下转型需要使用强制转换。运行C程序,控制台将输出:

    Exception in thread "main" java.lang.ClassCastException: a.b.A cannot be cast to a.b.B at

    a.b.C.main(C.java:14)

    A method

    A method

    B method 1

    B method 2

    其实B b2 = (B) a2处的向下转型代码后的注释已经提示你将发生运行时错误。为什么前一句向下转型代码可以,而后一句代码却出错?这是因为a1指向一个子类B的对象,所以子类B的实例对象b1当然也可以指向a1。而a2是一个父类对象,子类对象b2不能指向父类对象a2。那么如何避免在执行向下转型时发生运行时ClassCastException异常?使用5.7.7节学过的instanceof就可以了。我们修改一下C类的代码:

    A a2 = new A();

    if (a2 instanceof B) {

    B b2 = (B) a2;

    b2.aMthod();

    b2.bMethod1();

    b2.bMethod2();

    }

    这样处理后,就不用担心类型转换时发生ClassCastException异常了。

    展开全文
  • JAVA中的向上转型和向下转型

    千次阅读 2021-04-20 18:39:49
    一、向上转型和向下转型 向上转型和向下转型是在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
    在一个子类被创建的时候,首先会在内存中创建一个父类对象,然后在父类对象外部放上子类独有的属性,两者合起来形成一个子类的对象,所以子类可以继承父类中所有的属性方法,包括private修饰的属性方法,但是...
  • 简单理解Java中转型问题(向上转型和向下转型) —————————————————————————— 本文内容仅仅为个人的理解,仅供大家参考。如果本文中存在一些错误的地方还请大佬们指出,感激不尽。 ————...
  • Java向上转型和向下转型区别

    千次阅读 2020-01-15 13:29:27
    向下转型:通过引用类型强转,恢复了子类的成员变量以及方法。 1.代码实现: 可以发现,父类虽然指向了子类的实例对象,但是并不能调用子类对象的方法,编译器报错。此时我们可以看作被隐藏了,那么怎样才可以把...
  • 什么是向上转型和向下转型

    千次阅读 2022-02-09 10:42:51
    向上转型向下转型
  • 本文解析了java中向下转型和向上转型
  • Java关于向上转型向下转型区别

    千次阅读 2020-07-11 12:24:18
    向上转型和向下转型 对象既可作为它本身的类型使用,也可作为它的基类型使用,通过类型转换(转型)来实现,对象的类型转换分两种,把对某个对象的引用视为对其基类型的引用的做法称为“向上转型”,反之则称为“...
  • 本次博客带领大家学习多态中的向上转型和向下转型,在多态中是相当重要的。
  • java简单快速理解向上转型和向下转型
  • 展开全部java里面的向上转型和向下转型的具体好处如下:1.转型是在继承的基础上而言的,继承是面e69da5e887aa3231313335323631343130323136353331333337623364向对象语言中,代码复用的一种机制,通过继承,子类可以...
  • C#向上转型和向下转型
  • 向上转型 我们经常在代码中看到这样的写法 父类型 fat = new 子类型(); 这便是向上转型的实例,即父类引用指向子类对象。 一个完整的实例 package test; /** * @Author: Lemon * @Program: * @...
  • 向下转型:Cat cat = (Cat) a,必须要先经过向上转型的变量–再向下转型,此时cat就拥有子类自己定义的特有方法cat.sleep() instanceof用法:a instanceof Cat 这里a必须是经过向上转型后的父类对
  • 向上转型:父类引用指向子类对象 例如:子类student继承了父类person Person person = new Student(); 向上转型后的变化 关于方法:person可以调用子类父类公用...向下转型:子类引用指向父类对象 Father f=ne
  • Java中的向上转型和向下转型

    千次阅读 2021-12-16 14:34:02
    Java 中对象类型之间的类型转换(前提是两个类是父子关系) 1.向上转型:把子类对象直接赋给父类引用,自动进行类型转换。 静态方法/成员变量(包括静态...2.向下转型:将一个指向子类对象的父类引用赋给一个子类
  • Java的向上转型和向下转型利弊

    千次阅读 2018-12-04 18:29:00
    java的向上转型和向下转型 一、向上转型 好处:隐藏了子类型,提高了代码的扩展性。 坏处:只能使用父类的功能,不能使用子类特有功能,功能被限定。 使用场景:不需要面对子类型,通过提高扩展性,或者使用父类的...
  • 今天做了一个测试的题目,发现...java中对象的转型分为向上转型和向下转型一、对象的向上转型1.1、定义子类引用的对象转换为父类类型称为向上转型。通俗地说就是是将子类对象转为父类对象。此处父类对象可以是接口...
  • Java向上转型和向下转型(附具体样例)熬夜整理的关于Java向上和向下转型的样例,很的通俗易懂哦~~~~一.向上转型package com.sheepmu;class Animal{public void eat(){System.out.println("父类的 eating...");}}class...
  • 学习向上转型和向下转型怎么用没多难,但是为什么那样用,我搞了很多次没弄明白。没弄明白的原因是平时学习时之看例子,而例子一般都比较简单,没有对象之间的调用,一般就是一个对象调用自己的方法。首先看下怎么用...
  • 关于 向上转型和向下转型的理解

    千次阅读 2021-11-30 18:55:18
    向上转型的提出 1.父类 可以 接受 子类对象 2.这就叫向上转型,对于那个子类对象来说,本来是要赋值给子类引用的, 结果赋值给了,父类引用 3.... 4.为甚会有向上转型 1.... 2....向下转型 1
  • java 向上转型向下转型

    千次阅读 2022-05-01 21:56:07
    在一个子类被创建的时候,首先会在内存中创建一个父类对象,然后在父类对象外部放上子类独有的属性,两者合起来形成一个子类的对象,所以子类可以继承父类中所有的属性方法,包括private修饰的属性方法,但是...
  • 我的处女作《Canvas系列教程》在我的Github上正在连载更新,希望能得到您...其他网上关于向上转型和向下转型并不能完全使读者透彻的了解,因此我决定重写一篇教程来让大家简单理解。 向上转型:将子类转化为父类。...
  • 多态的向上转型: (1)本质:父类的引用指向了子类对象 (2)语法: 父类类型 引用名 = new 子类类型(); (3)特点(规则):编译类型看左边,运行类型看右边。 可以调用父类中的所有成员(遵守访问权限)(实际...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,536
精华内容 15,814
热门标签
关键字:

向上转型和向下转型的区别