精华内容
下载资源
问答
  • Java向上转型和向下转型的区别

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

    前言:

    • 向上转型:父类引用类型指向了子类的实例对象,此时无法使用子类里的成员变量以及方法。
    • 向下转型:通过引用类型强转,恢复了子类的成员变量以及方法。

    1.代码实现:

    在这里插入图片描述

    • 可以发现,父类虽然指向了子类的实例对象,但是并不能调用子类对象的方法,编译器报错。此时我们可以看作被隐藏了,那么怎样才可以把被隐藏的方法放出来呢?此时就需要向下转型。

    2.实现向下转型:

    • 将a强转为Son引用类型。
    ((Son)a).sleep();   //调用子类的sleep方法
    

    4.此时执行程序:
    在这里插入图片描述

    • 成功向下转型,那么这样有什么作用呢?其实,无论是上转还是下转都是为了让类的使用范围和适用范围发生变化,以便操作不同范围的变量或者方法。这样其实就是一个java的继承多态,利于程序扩展.。我们需要这种设计方式,才会写出更易维护、简洁的代码。
    展开全文
  • 跟汤老师学Java笔记:总结多态 完成:第一遍 1.实现多态条件是什么? (1).继承存在(继承是多态基础,没有...父类引用变量指向子类对象(向上转型) 2.多态优点是什么 减少代码量 提高可扩展性和可维护性 ...

    26.多态的总结:多态有哪两种???运行时多态常见哪三种实现方式???运行时多态的前提是什么???多态中成员的访问特点是什么???多态的好处和弊端是什么???向上转型和向下转型的区别???

    学习:第7遍


    1.多态有哪两种???

    第一种:编译时多态
    实现方式:方法重载

    第二种:运行时多态
    直到系统运行时
    才根据实际情况决定实现何种操作
    实现方式:方法重写


    2.运行时多态常见哪三种实现方式???

    方式一:左边父类是普通类
    右边子类是普通类
    存在继承关系

    Father  father =  new Son() ;
    

    方式二:左边父类Animal类是抽象类
    右边子类Cat是普通类
    存在继承关系

    Animal animal = new Cat();
    

    方式三:左边CodeImpl 是接口
    右边Student是实现了接口的普通类
    存在实现关系

    CodeImpl coder = new Student() 
    

    3.运行时多态的前提是什么???

    一:有继承关系
    二:有方法重写
    三:有父类引用指向子类实例


    4.多态中成员的访问特点是什么???

    成员变量:编译看左边,执行看左边。
    成员方法:编译看左边,执行看右边。


    5.多态的好处和弊端是什么???

    多态的好处:提高了程序的扩展性
    具体体现:定义方法,使用父类型作为参数
    将来调用时,调用具体的子类实例

    多态的弊端:不能使用子类的特有功能


    6.向上转型和向下转型的区别???

    向上转型:
    本质是子类转换为父类
    是自动类型转换
    父类引用指向子类实例

    向下转型:
    本质是父类转化为子类
    是强制类型转换
    前提用instanceof判断
    是否可转换为指定子类

    展开全文
  • 向上转型和向下转型 对象既可作为它本身类型使用,也可作为它基类型使用,通过类型转换(转型)来实现,对象类型转换分两种,把对某个对象引用视为对其基类型引用做法称为“向上转型”,反之则称为“向...

    向上转型和向下转型

    对象既可作为它本身的类型使用,也可作为它的基类型使用,通过类型转换(转型)来实现,对象的类型转换分两种,把对某个对象的引用视为对其基类型的引用的做法称为“向上转型”,反之则称为“向下转型

    1. 向上转型对象不能操作子类新增的成员属性和方法(失掉了这部分功能)
    2. 向上转型对象可以操作子类继承或隐藏的成员变量,也可以使用子类继承或重写的方法
    3. 可以将向上转型对象再强制转换到它本来的类型(向下转型),该对象就又具备了其所有的属性和方法
    4. 向上转型对象操作子类继承或重写的方法时,就是通知对应的子类对象去调用这些方法
    package inter;
    
    public class SuperClass {
    
    	private int x;
    	public SuperClass(int x) {
    		this.x = x;
    		System.out.println("父类构造方法");
    		// TODO Auto-generated constructor stub
    	}
    	public void printInfo() {
    		System.out.println("父类方法:"+this.x);
    	}
    	public static void main(String[] args) {
    //		向上转型,把创建的子类对象赋给父类的引用
    		SuperClass p = new ChildClass(10);
    		p.printInfo();
    //		向上转型后,子类中存在但父类中不存在的方法无法使用
    //		p.display();
    //		向下转型,把父类的引用强制还原为子类的引用
    		ChildClass p2 = (ChildClass)p;
    		p2.display();
    //		instanceof判断实例对象是否属于某个类
    		System.out.println(p instanceof SuperClass);
    //		true
    		System.out.println(p2 instanceof ChildClass);
    //		true
    		SuperClass p3 = new SuperClass(10);
    //		父类对象p3不是子类的实例
    		System.out.println(p3 instanceof ChildClass);
    //		false
    		
    //		创建父类的对象不能转换为子类,以下用法错误
    //		ChildClass p4 = (ChildClass)p3;
    		
    		ChildClass p4 = new ChildClass(20);
    		p4.display();
    //		子类对象属于父类
    		System.out.println(p4 instanceof SuperClass);
    //		true
    		
    	}
    
    }
    class ChildClass extends SuperClass{
    	private int x;
    	ChildClass(int x){
    		super(x);
    		this.x = x;
    		System.out.println("子类构造方法");
    	}
    	public void display() {
    		System.out.println("子类方法:"+this.x);
    	}
    	
    }
    
    
    展开全文
  • 父子对象之间转换分为了向上转型和向下转型,它们区别如下: 向上转型 : 通过子类对象(小范围)实例化父类对象(大范围),这种属于自动转换 向下转型 : 通过父类对象(大范围)实例化子类对象(小范围),这种属于强制转换 ...

    转自:https://www.cnblogs.com/lifexy/p/10812841.html

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

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

    向上转型

    示例代码1:

    class A {
             public void print() {
                      System.out.println("A:print");
             }
    }
    
    class B extends A {
             public void print() {        
                      System.out.println("B:print");
             }
    }
    
    public class Test{
             public static void main(String args[])
             {
                      A a = new B();          //通过子类去实例化父类
                      a.print();
             }
    }
    

    运行:
    在这里插入图片描述
    如上图所示,可以看到打印的是class B的print,这是因为我们通过子类B去实例化的,所以父类A的print方法已经被子类B的print方法覆盖了.从而打印classB的print.

    类似于C++的virtual虚函数。

    这样做的意义在于:

    当我们需要多个同父的对象调用某个方法时,通过向上转换后,则可以确定参数的统一.方便程序设计(参考下面示例)

    示例2-向上转型的作用分析

    class A {
             public void print() {
                      System.out.println("A:print");
             }
    }
    
    class B extends A {
             public void print() {        
                      System.out.println("B:print");
             }
    }
    
    class C extends B {
             public void print() {        
                      System.out.println("C:print");
             }
    }
    
    public class Test{
             public static void func(A a)
             {
                      a.print();
             }
    
             public static void main(String args[])
             {
                      func(new B());  //等价于 A a =new B();
                      func(new C());  //等价于 C c =new C();
             }
    }
    

    运行:
    在这里插入图片描述
    PS:向上转型时,父类只能调用父类方法或者子类覆写后的方法,而子类中的单独方法则是无法调用的.

    向下转型

    在java中,向下转型则是为了,通过父类强制转换为子类,从而来调用子类独有的方法(向下转型,在工程中很少用到).

    为了保证向下转型的顺利完成,在java中提供了一个关键字:instanceof,通过instanceof可以判断某对象是否是某类的实例,如果是则返回true,否则为false,instanceof使用如下:

    A a = new B();                 //向上转型 (B类是A的子类)
    
    a instanceof A;                //返回true.
    a instanceof B;                //返回true
    a instanceof C;                //返回false
    

    接下来,我们便来分析向下转型的意义.

    示例-向下转型的作用分析

    class A {
             public void print() {
                      System.out.println("A:print");
             }
    }
    
    class B extends A {
             public void print() {        
                      System.out.println("B:print");
             }
             public void funcB(){
                      System.out.println("funcB");
             }
    }
    
    class C extends A {
             public void print() {        
                      System.out.println("C:print");
             }
             public void funcC(){
                      System.out.println("funcC");
             }
    }
    
    public class Test{
             public static void func(A a)
             {
                      a.print();
                      if(a instanceof B)
                      {
                              B b = (B)a;   //向下转型,通过父类实例化子类
                              b.funcB();    //调用B类独有的方法
                      }
                      else if(a instanceof C)
                      {
                              C c = (C)a;  //向下转型,通过父类实例化子类
                              c.funcC();   //调用C类独有的方法
                      }
             }
    
             public static void main(String args[])
             {
                      func(new A());   
                      func(new B());
                      func(new C());
             }
    }
    

    运行
    在这里插入图片描述
    从上面打印可以看到,我们成功通过向下转型来调用B类和C类独有的方法.

    展开全文
  • 简单理解Java中转型问题(向上转型和向下转型) —————————————————————————— 本文内容仅仅为个人理解,仅供大家参考。如果本文中存在一些错误地方还请大佬们指出,感激不尽。 ————...
  • 父子对象之间转换分为了向上转型和向下转型,它们区别如下: 向上转型: 通过子类对象(小范围)实例化父类对象(大范围),这种属于自动转换 向下转型: 通过父类对象(大范围)实例化子类对象(小范围),这种属于强制转换 ...
  •   Java 转型主要是用在继承和接口实现场景,Java 转型可分为向上转型和向下转型区别如下: 向上转型:通过子类对象实例化父类对象,这属于自动转换。 向下转型:通过父类对象实例化子类对象,这属于强制转换...
  • 对于创建对象是向上转型还是向下转型向上转型:只能调用与父类引用中父类相同方法,不能调用子类中自己定义方法;如果在子类中重写了,则调用是子类中方法;   向下转型:可以调用父类中方法,也...
  • 文章目录父子对象之间转换分为了向上转型和向下转型,它们区别如下:向上转型注意:向上转型时,父类只能调用父类方法或者子类覆写后方法,而子类中单独方法则是无法调用.向下转型instanceof向下转型意义 父子...
  • 父子对象之间转换分为了向上转型和向下转型,它们区别如下: 向上转型: 通过子类对象(小范围)实例化父类对象(大范围),这种属于自动转换 向下转型: 通过父类对象(大范围)实例化子类对象(小范围),这种属于强制转换 ...
  • 父子对象之间转换分为了向上转型和向下转型,它们区别如下: 向上转型 : 通过子类对象(小范围)实例化父类对象(大范围),这种属于自动转换 向下转型 : 通过父类对象(大范围)实例化子类对象(小范围),这种属于强制转换 ...
  • 第九天:继承 ...1.thissuper的区别 this:代表当前的对象引用,this可以调用到本类的属性方法 this(name,age)也可以调用 本类的构造方法 super:调用父类属性方法以及super(name,age)调用父
  • 今天下午小龙在练习instanceof用法时突然想到javaupcating 和 downcasting 好像与此有关联,于是自己写了一个相关案例,在此.../** java向上转型和向下转型,以及用instanceof方法来防止向下转型错误  * 接口说明
  • 父子对象之间转换分为了向上转型和向下转型,它们区别如下: 向上转型 : 子类引用对象转换为父类类型,这种属于自动转换。 向下转型 : 父类引用对象转换为子类类型,这需要借助强制转换。 其实我更想说,从子转...
  • java的向上向下转型

    2020-05-21 11:44:43
    父子对象之间转换分为了向上转型和向下转型,它们区别如下: 向上转型 : 通过子类对象(小范围)实例化父类对象(大范围),这种属于自动转换 向下转型 : 通过父类对象(大范围)实例化子类对象(小范围),这种属于强制转换 ...
  • 多态 多态指是同一种行为在不同对象身上有不同表现形式 多态实现条件 1.要有继承 2.要有重写 3.父类引用指向子类对象 举个例子: Person p = new Student(); 这是一种向上转型 ...向下转型: 1.指向
  • 1.final关键字 final修饰特点 ...方法重写是指子类中出现了父类中一模一样方法声明(方法名,参数列表,返回值类型),也被称为方法覆盖,方法复写。 例: 父类: public class Animal { String na...
  • Java从入门到放弃09—多态/向上转型/向下转型/多态内存图/抽象类/关键字abstract不能哪些关键字共存/接口/类与类,类与接口,接口与接口的关系/抽象类与接口的区别 01 多态 多态指的是某个事物,在某个时刻所表现...

空空如也

空空如也

1 2 3 4 5 6
收藏数 110
精华内容 44
关键字:

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