精华内容
下载资源
问答
  • java向下转型引用和直接实例化引用的区别
    千次阅读
    2017-04-20 09:55:24

    复习java遇到个问题,发现书上向下转型的例子得到的引用和直接实例化子对象得到的引用拥有同样的方法和变量


    于是猜测这两种引用得到的内容是相同的


    举个例子证明一下

    A a=new B();

    B b=(B) a;


    B b1=new B()


    按照java的储存方式


    A a=new B();//a引用地址应该放到栈里,B对象放入堆

    B b=(B) a;//a引用地址赋给b引用,根据栈的特点,a,b指向同一地址,即a==b

    这里可以用if(a==b)确认



    B b1=new B()//B放入堆,b放入栈指向B

    因此猜测这两种方法得到的对象是相同的;

    根据堆的特点两次new的B并不在同一个地址


    先在B类里重写equals()方法

    public boolean equals(Object obj) {
    if(getClass()==obj.getClass())
    return true;
    else
    return false;
    }

    然后

    if(b.equals(b1))
                System.out.println("yes");
            else
                System.out.println("no");

    返回true,说明向下转型得到对象与直接实例化得到的对象是相同的,猜测成立


    至于他们的区别


    举一个用到向下转型的例子

    String str=(String)request.getParameter("info");

    可以这样写

    Object ob=new String();
    ob=request.getParameter("info");
    String checkcode1 = (String) ob;

    很明显用到了向下转型

    它和String checkcode=new String("");的区别,我们并不知道getParameter("info")具体的值,假设是1,可以把1放到""中去,那么两种引用获得内容是一样的,都是1。与上面的结论不冲突


    但是获得的内容"1"的意义不一样

    做个假设:object代表最高抽象ob,第一个方法是假设人request喝了什么水getParameter(),得到的热水是object的一员,但需要输出print()热水,文字string

    有这个方法print(),用向下转型在这里可以解释这个过程:被作为热水的事物ob可以看作是一段文字输出。

    这和直接的实例化文字“热水”去输出内容是一样,但意义不同

    第一种方法可以知道热水是人喝的,而第二种只知道热水


    所以结论应该是,引用到的内容一样但意义不同


    更多相关内容
  • class A{ } class B extends A { } 向下转型: A a = new B(); B b = (B)a; 直接调用子类: B b = new B(); 这两个 b 实例什么区别
  • Java对象类型向上转型和向下转型

    万次阅读 多人点赞 2019-03-20 19:16:43
    在一个子类被创建的时候,首先会在内存中创建一个父类对象,然后在父类对象外部放上子类独有的属性,两者合起来形成一个子类的对象,所以子类可以继承父类中所有的属性和方法,包括private修饰的属性和方法,但是...

    基础知识: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对象类型转换:向上转型和向下转型 将一个类型强制转换成另一个类型的过程被称为类型转换。本节所说的对象类型转换,是指存在继承关系的对象,不是任意类型的对象。当对不存在继承关系的对象进行强制类型转换时...

    Java对象类型转换:向上转型和向下转型

    将一个类型强制转换成另一个类型的过程被称为类型转换。本节所说的对象类型转换,是指存在继承关系的对象,不是任意类型的对象。当对不存在继承关系的对象进行强制类型转换时,会抛出强制类型转换异常(java.lang.ClassCastException)。

    Java 语言允许某个类型的引用变量引用子类的实例,而且可以对这个引用变量进行类型转换。Java 中引用类型之间的类型转换(前提是两个类是父子关系)主要有两种,分别是向上转型(upcasting)和向下转型(downcasting)。

    1)向上转型

    父类引用指向子类对象为向上转型,语法格式如下:

    fatherClass obj = new sonClass();
    

    其中,fatherClass 是父类名称或接口名称,obj 是创建的引用变量,sonClass 是子类名称。

    向上转型就是把子类对象直接赋给父类引用,不用强制转换。使用向上转型可以调用父类类型中的所有成员,不能调用子类类型中特有成员,最终运行效果看子类的具体实现。可总结为:编译时看左边,运行时看右边 。

    2)向下转型

    与向上转型相反,子类对象指向父类引用为向下转型,语法格式如下:

    sonClass obj = (sonClass) fatherClass;
    

    其中,fatherClass 是父类名称,obj 是创建的引用变量,sonClass 是子类名称。

    向下转型可以调用子类类型中所有的成员,不过需要注意的是如果父类引用对象指向的是子类对象,那么在向下转型的过程中是安全的,也就是编译是不会出错误。但是如果父类引用对象是父类本身,那么在向下转型的过程中是不安全的,编译不会出错,但是运行时会出现我们开始提到的 Java 强制类型转换异常,一般使用 instanceof 运算符来避免出此类错误。

    例如,Animal 类表示动物类,该类对应的子类有 Dog 类,使用对象类型表示如下:

    Animal animal = new Dog();    // 向上转型,把Dog类型转换为Animal类型
    Dog dog = (Dog) animal; // 向下转型,把Animal类型转换为Dog类型
    

    例 1

    下面通过具体的示例演示对象类型的转换。例如,父类 Animal 和子类 Cat 中都定义了实例变量 name、静态变量 staticName、实例方法 eat() 和静态方法 staticEat()。此外,子类 Cat 中还定义了实例变量 str 和实例方法 eatMethod()。

    父类 Animal 的代码如下:

    public class Animal {
        public String name = "Animal:动物";
        public static String staticName = "Animal:可爱的动物";
        public void eat() {
            System.out.println("Animal:吃饭");
        }
        public static void staticEat() {
            System.out.println("Animal:动物在吃饭");
        }
    }
    

    子类 Cat 的代码如下:

    public class Cat extends Animal {
        public String name = "Cat:猫";
        public String str = "Cat:可爱的小猫";
        public static String staticName = "Dog:我是喵星人";
        public void eat() {
            System.out.println("Cat:吃饭");
        }
        public static void staticEat() {
            System.out.println("Cat:猫在吃饭");
        }
        public void eatMethod() {
            System.out.println("Cat:猫喜欢吃鱼");
        }
        public static void main(String[] args) {
            Animal animal = new Cat();
            Cat cat = (Cat) animal; // 向下转型
            System.out.println(animal.name); // 输出Animal类的name变量
            System.out.println(animal.staticName); // 输出Animal类的staticName变量
            animal.eat(); // 输出Cat类的eat()方法
            animal.staticEat(); // 输出Animal类的staticEat()方法
            System.out.println(cat.str); // 调用Cat类的str变量
            cat.eatMethod(); // 调用Cat类的eatMethod()方法
        }
    }
    

    通过引用类型变量来访问所引用对象的属性和方法时,Java 虚拟机将采用以下绑定规则:

    • 实例方法与引用变量实际引用的对象的方法进行绑定,这种绑定属于动态绑定,因为是在运行时由 Java 虚拟机动态决定的。例如,animal.eat() 是将 eat() 方法与 Cat 类绑定。
    • 静态方法与引用变量所声明的类型的方法绑定,这种绑定属于静态绑定,因为是在编译阶段已经做了绑定。例如,animal.staticEat() 是将 staticEat() 方法与 Animal 类进行绑定。
    • 成员变量(包括静态变量和实例变量)与引用变量所声明的类型的成员变量绑定,这种绑定属于静态绑定,因为在编译阶段已经做了绑定。例如,animal.name 和 animal.staticName 都是与 Animal 类进行绑定。

    对于 Cat 类,运行时将会输出如下结果:

    Animal:动物
    Animal:可爱的动物
    Cat:吃饭
    Animal:动物在吃饭
    Cat:可爱的小猫
    Cat:猫喜欢吃鱼
    

    强制对象类型转换

    Java 编译器允许在具有直接或间接继承关系的类之间进行类型转换。对于向下转型,必须进行强制类型转换;对于向上转型,不必使用强制类型转换。

    例如,对于一个引用类型的变量,Java 编译器按照它声明的类型来处理。如果使用 animal 调用 str 和 eatMethod() 方法将会出错,如下:

    animal.str = "";    // 编译出错,提示Animal类中没有str属性
    animal.eatMethod();    // 编译出错,提示Animal类中没有eatMethod()方法
    

    如果要访问 Cat 类的成员,必须通过强制类型转换,如下:

    ((Cat)animal).str = "";    // 编译成功
    ((Cat)animal).eatMethod();    // 编译成功
    

    把 Animal 对象类型强制转换为 Cat 对象类型,这时上面两句编译成功。对于如下语句,由于使用了强制类型转换,所以也会编译成功,例如:

    Cat cat = (Cat)animal;    // 编译成功,将Animal对象类型强制转换为Cat对象类型
    

    类型强制转换时想运行成功就必须保证父类引用指向的对象一定是该子类对象,最好使用 instanceof 运算符判断后,再强转,例如:

    Animal animal = new Cat();
    if (animal instanceof Cat) {
        Cat cat = (Cat) animal; // 向下转型
        ...
    }
    

    子类的对象可以转换成父类类型,而父类的对象实际上无法转换为子类类型。因为通俗地讲,父类拥有的成员子类肯定也有,而子类拥有的成员,父类不一定有。因此,对于向上转型,不必使用强制类型转换。例如:

    Cat cat = new Cat();
    Animal animal = cat;    // 向上转型,不必使用强制类型转换
    

    如果两种类型之间没有继承关系,那么将不允许进行类型转换。例如:

    Dog dog = new Dog();
    Cat cat = (Cat)dog;    // 编译出错,不允许把Dog对象类型转换为Cat对象类型
    
    展开全文
  • 在一个子类被创建的时候,首先会在内存中创建一个父类对象,然后在父类对象外部放上子类独有的属性,两者合起来形成一个子类的对象,所以子类可以继承父类中所有的属性和方法,包括private修饰的属性和方法,但是...

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

    一、转型的分类和动态绑定介绍

    1、转型的分类

    转型是在继承的基础上而言的,继承是面向对象语言中,代码复用的一种机制,通过继承,子类可以复用父类的功能,如果父类不能满足当前子类的需求,则子类可以重写父类中的方法来加以扩展。

    向上转型:子类引用的对象转换为父类类型称为向上转型。通俗地说就是用父类的引用变量去引用子类的实例对象,此处父类对象可以是接口。向上转型属于自动类型转换。

    向下转型:父类引用的对象转换为子类类型称为向下转型。向下转型属于强制类型转换。

    2、动态绑定介绍

    程序绑定的概念:绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来。对Java来说,绑定分为静态绑定和动态绑定,或者叫做前期绑定和后期绑定

    静态绑定:在程序执行前方法已经被绑定,此时由编译器或其它连接程序实现。例如:C。针对Java简单的可以理解为程序编译期的绑定;这里特别说明一点,Java当中的方法只有final,static,private和构造方法是前期绑定
    动态绑定:

    动态绑定:在运行时根据具体对象的类型进行绑定。若一种语言实现了后期绑定,同时必须提供一些机制,可在运行期间判断对象的类型,并分别调用适当的方法。也就是说,编译器此时依然不知道对象的类型,但方法调用机制能自己去调查,找到正确的方法主体。不同的语言对后期绑定的实现方法是有所区别的。但我们至少可以这样认为:它们都要在对象中安插某些特殊类型的信息。

    动态绑定的过程:JVM虚拟机提取对象的实际类型的方法表—>JVM虚拟机搜索方法签名—>调用方法。

    二、向上转型

    1、前篇文章提到过,在多态中需要将子类的引用赋给父类对象,只有这样该引用才能够具备调用该子类的方法的能力,其实这就是向上转型。

    向上转型,就是用父类的引用变量去引用子类的实例,这是允许的。当向上转型之后,父类引用变量可以访问子类中属于父类的属性和方法,但是不能访问子类独有的属性和方法,因为向上转型后子类对象会丢失身份。

    2、举个栗子:

    假设有一个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();

    运行结果如下图所示:

    向上转型需要注意的问题:

    向上转型时,父类指向子类引用对象会遗失除与父类对象共有的其他方法,也就是在转型过程中,子类的新有的方法都会遗失掉,在编译时,系统会提供找不到方法的错误。

    所以,子类对象当成父类对象,只能调用父类的成员,如果子类重写了父类的方法,就根据这个引用指向调用子类重写的这个方法。这个调用过程就称为“动态绑定”。

    三、向下转型

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

    /*
    *  第一段代码
    **/
    Fruit fruit = new Apple();
    Apple apple = (Apple) 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");
        }
    }
    
     Fruit fruit = new Apple();
     Orange orange = (Orange) fruit;//强制类型转换

    代码分析:

    第一段代码向下转型成功:因为fruit引用的对象原本就是Apple对象向上转型得到的,在对fruit向下转型后得到的还是Apple类的对象,能够被Apple类的引用变量引用;

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

    总结:

    情况一:如果父类引用的对象如果引用的是指向的子类对象,那么在向下转型的过程中是安全的。也就是编译是不会出错误的。

    情况二:如果父类引用的对象是父类本身或者原本不是子类对象,那么在向下转型的过程中是不安全的,编译不会出错,但是运行时会出现java.lang.ClassCastException错误。它可以使用instanceof来避免出错此类错误。

    四、转型的好处

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

    假设在主类中定义了一个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()方法,减少了代码量
     

    注意:向上转型常用于多态中,既能减少代码量,又能提高程序的扩展性。

    展开全文
  • 有关向上向下转型 // Student extends Person Person person = new Student(); 实例化Person类,并新建一个Student类的引用变量引用该实例。 这个对象可以调用Person类的方法,如果方法被子类Student覆写,则调用...
  • 转型是在继承的基础上而言的,继承是面向对象语言中,代码复用的一种机制,通过继承...此处父类对象可以是接口向下转型:父类引用的对象转换为子类类型称为向下转型。前者是一个向上转型,Animal dog 引用指向new Do...
  •   向上转型——用父类的引用变量去引用子类的实例(或者说子类对象给父类引用变量赋值),这是允许的。   向上转型之后,父类引用变量只能调用父类中的属性和方法,不能访问子类独有的属性和方法。如果父类访问...
  • 引用对象之间的转型:public class CastTest { public static void main(String[] args) { /******1.向上转型*********/ Animal animal = new Bird(); animal.walk(); /* Animal animal = new Animal()...
  • 恰饭广告上转型对象:子类创建对象 并将这个对象引用赋值给父类的对象。语法格式:Father f=new Son();注意事项:1、上转型对象是由子类创建的,但上转型对象会失去子类的一些属性和方法。2、上转型对象调用方法时,...
  • 有关向上造型和向下造型的核心精髓就是一句话:在创建实例的时候到底是子类的实例还是父类的实例。如果是子类的实例,则就完全可以进行强制类型转换。 向上造型 父类的引用指向子类的对象实例化成子类,可用方法使...
  • ☀️本期文章将学习 [JavaSE] 面向对象编程(多态深度理解、向下转型、super&&this、大坑),我是博主Nick。✨ ✨我的博客主页:Nick_Bears ꧔ꦿ ꧔ꦿ博文内容如对您有所帮助,还请给个点赞 + 关注 + 收藏✨ ​
  • 从 2 个名词开始说起:向上转型(upcasting)、向下转型(downcasting)。 举个例子:有2个类,Father 是父类,Son 类继承自 Father。 第 1 个例子: Father f1 = new Son(); // 这就叫 upcasting (向上转型) // ...
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼之前一直搞不明白,向下转型的实际意义,虽然知道向下转型怎么写, 现在我来讲解下 向下转型 的实际作用,如果有错的话,大家可以指出, 如果认为我说的对的话可以给个赞....
  • 在谈转型之前我们需要了解,关于引用变量的类型和具体实例之间的关系. 举个例子: public class Person { protected String name; protected Integer age; //在构建属性和方法的时候需要注意,访问权限控制符.需要...
  • 向上转型与向下转型详解

    千次阅读 2020-03-25 17:21:19
    让我们先来了解一下,怎么用转型。 转型 要转型,首先要有继承。继承是面向对象语言中一个代码复用的机制,简单说就是子类继承了父类中的非私有属性和可以继承...向下转型: 通过父类对象 (大范围) 实例化子类对象 ...
  • (2):向下转型,所谓的向下转型,也就是说父类对象可以转换为子类对象,但需要注意的是,这时必须进行强制类型转换。 以上内容可以概括为下面二句话。 1:向上转型可以自动完成。 2:向下转型必须进行强制类型转换。 ...
  • java向下转型

    千次阅读 2019-06-08 23:03:21
    对象向下转型中,父类实例是不可能强制转换成任意子类实例,必须先通过子类实例化,利用向上转型让父类对象与具体子类实例发生联系后才可以向下转型,否则将出现ClassCastException异常 ...
  • java对象转型(向上转型和向下转型向下转型和向上转型是什么意思向上转型和向下转型的基本公式: 向下转型和向上转型是什么意思 基本数据类型,转换可以通过隐性和显性(强制)类型转换,例如float类型转成int类型...
  • 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 方法...
  • 对象向下转型:子类 子类对象 = (子类)父类实例 主要详细讲解向上转型和向下转型 转型的前提: 要继承,方法重写 向上转型:核心本质:使用的是哪一个子类(new在哪里),而且调用的方法...
  • 三分钟带你搞懂什么是向上转型和向下转型

    千次阅读 多人点赞 2020-03-27 11:39:08
    什么是向上转型? 通过在网上查了资料,和普遍的介绍,一句话总结就是“父类引用指向子类对象”,例: Human h=new Human(); h.eat();//人类 Animal a=new Animal(); a.eat();//动物 //父类-Human,子类-Animal,a...
  • 多态 某一个事物,在不同时刻表现出来的不同状态。 举例: Cat c=new Cat();...向上转型和向下转型 向上转型:子类对象变为父类对象 格式:父类 父类对象=子类实例,自动转换; public class ZhuanXing...
  • 向下转型 : 通过父类对象(大范围)实例化子类对象(小范围),这种属于强制转换 class A { public void print() { System.out.println("A:print"); } } class B extends A { public void print() {
  • 父子对象之间的转换分为了向上转型和向下转型,它们区别如下: 向上转型: 通过子类对象(小范围)实例化父类对象(大范围),这种属于自动转换 向下转型: 通过父类对象(大范围)实例化子类对象(小范围),这种属于强制转换 ...
  • 在一个子类被创建的时候,首先会在内存中创建一个父类对象,然后在父类对象外部放上子类独有的属性,两者合起来形成一个子类的对象,所以子类可以继承父类中所有的属性和方法,包括private修饰的属性和方法,但是...
  • 父子对象之间的转换分为了向上转型和向下转型,它们区别如下: 向上转型:通过子类对象(小范围)实例化父类对象(大范围),这种属于自动转换 失去了子类新增的方法,只能调用父类里面已经有的方法 向下转型:通过父类...
  • 通过子类对象(小范围)实例化父类对象(大范围),这种属于是自动转换。在写程序时大多是结合多态使用。 代码示例: import sun.rmi.runtime.Log; import java.util.ArrayList; import java.util.Arrays; import...
  • 多态的最终体现为:父类的引用变量可以指向子类对象。 多态的前提是必须有子父类关系,或者类实现接口关系,否则无法完成多态。 在使用多态后,父类的引用变量调用方法时,会调用子类重写后的方法。 二、多态使用...
  • 对象向下转型中,父类实例是不可能强制转换成任意子类实例,必须先通过子类实例化,利用向上转型让父类对象与具体子类实例发生联系后才可以向下转型,否则将出现ClassCastException异常。 instanceof 的使用: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,242
精华内容 12,096
关键字:

向下转型实例化什么对象