精华内容
下载资源
问答
  • 主要介绍了Java向上转型和向下转型实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了 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 强制类型转换异常

     

    如果觉得对你有帮助,点个赞再走吧!

    展开全文
  • 在主类中people类的声明对象分别作为Chinapeople和Americanpeople类对象的上转型对象,并让这个上转型对象调用showname方法。编写一个people类,该类有string类型的成员变量firstname和lastname来存放people对象的...
  • Java对象类型向上转型和向下转型

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

    基础知识: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()方法,减少了代码量。

    展开全文
  • 在谈转型之前我们需要了解,关于引用变量的类型和具体实例之间的关系. 举个例子: public class Person { protected String name; protected Integer age; //在构建属性和方法的时候需要注意,访问权限控制符.需要...

    1.前言
    在谈转型之前我们需要了解,关于引用变量的类型和具体实例之间的关系.
    举个例子:

    public class Person {
        protected String name;
        protected Integer age;
        //在构建属性和方法的时候需要注意,访问权限控制符.需要能够被子类所访问到.
        //public 公开的,本模块内所有的包都可以访问.  protect 本类,同包,子类,子类包. defailt 默认,同一个包. private 本类.
    
        //通过构造器初始化赋值
        public Person(){
            name ="personName";
            age =24;
        }
    
        void sayHello(){
            System.out.println("sayHello 名字:"+name+" 年龄:"+age);
        }
    
        void sayGood(){
            System.out.println("sayGood 名字:"+name+" 年龄:"+age);
        }
    }
    
    
    Person person = new Person();
    

    上面一行的代码的含义,左边的new Person(); 也就是调用构造方法是以Person类为模板新建了一个对象.左边的Person person 意思是声明一个引用变量,这个变量的名字叫 person ,类型是Person ,他说指引的对象实例,就是右边刚刚创建出来的那个实例.

    如果使用person去做某件事情,调用一个方法,例如person.sayHello();那么实际上是他所指引的对象实例在具体操作,他本身也就是说 引用变量本身person 并不具有什么行为属性.因为他不是一个实体,他就是一个遥控器,里面是他所指引对象的在内存中的地址.

    而他能够指引哪些对象呢,也是有规定的,不是所有对象他都能够去指引(去遥控),是需要和他的类型相匹配.是的,这个引用变量也是有一个类型.相当于他的身份,他有了这个身份才能去指引 对应的对象实例,然后遥控对象实例进行操作.

    2.向上转型

    2.1 构建子类

    public class Student extends Person {
        protected Integer studentNum;//学号 学生子类特有的
    
        //通过构造器初始化 赋值
        Student(){
            name ="ling"; //对继承父类的属性重新 赋值
            studentNum = 18599306; //给子类自己特有的属性赋值
        }
    
        @Override
        void sayGood() {
           // super.sayGood(); 不使用父类的方法 我们来重写他的方法
            System.out.println("Student sayGood 名字:"+name+" 年龄:"+age+" 学号:"+studentNum);
        }
    
        //添加子类特有方法
        void doStudy(){
            System.out.println("我是一名学生,我的爱好是喝花酒:"+name+" 年龄:"+age+" 学号:"+studentNum);
        }
    }
    

    2.2在向上转型之前,我们需要明白我们为什么要这么做.那么我们可以看看在不做向上转型之前,父类类型引用和子类类型引用各自可以做哪些事情.

    public class Hello {
        public static void main(String[] args) {
            Person person =new Person();
            Integer age = person.age;
            String name = person.name;
            person.sayGood();
            person.sayHello();
            System.out.println("Person打印 年龄:"+age+" 名字:"+name);
            //可以看到 使用父类引用变量和父类实例 可以访问父类里面的所有属性. 
        }
    }
    

    打印如下

    sayGood 名字:personName 年龄:24
    sayHello 名字:personName 年龄:24
    Person打印 年龄:24 名字:personName
    
    //同理 我们来尝试使用子类引用变量 和 子类实例访问
    Student student =new Student();
    String name1 = student.name;
    Integer age1 = student.age;
    Integer studentNum = student.studentNum;
    student.sayGood();
    student.sayHello();
    student.doStudy();
    System.out.println("Student打印 名字:"+name+"年龄"+age+"学号"+studentNum);
    

    打印如下

    Student sayGood 名字:ling 年龄:24 学号:18599306
    sayHello 名字:ling 年龄:24
    我是一名学生,我的爱好是喝花酒:ling 年龄:24 学号:18599306
    Student打印 名字:ling年龄24学号18599306
    

    我们可以看到,继承父类的属性,如果没有被修改则被保留 例如age.修改后,就被覆盖掉了 例如name,sayGood().而自己访问自己特有的属性和方法那是肯定没有问题的 例如studentNum,doStudy();.

    但是如果我想使用父类的引用变量访问自己已经被改造的方法呢.(本身是自己有的,但是被子类改造了,访问改造后的),我们来试一下.

        // 当我尝试使用父类引用和实例 直接访问子类特有的属性和方法时,编译报错了.
       person.studentNum;
        person.doStudy();
    

    报错为 Cannot resolve symbol ‘studentNum’ ,经过我千帆万苦使用翻译后说是 无法解析符号.也就是找不到这样的属性或者方法.
    我抽了一根烟,长叹一声"老天爷,你为什么要这样对我!!"
    说时迟那时快,我想起了 前言中我们提到的那个概念.引用类型变量本身是一个遥控器,他本身不具备属性和行为,而我们使用 父类类型引用变量 Person person,是遥控 new Person(); 这个对象,然后去操作他子类对象实例才有的东西,这不是笑话吗?
    呜呼哉!天不亡我,命不该如此.

    2.3 办法就是 我们使用父类类型引用变量 Person p去 遥控子类实例 new Student();操作子类实例自身的属性和方法,岂不美哉.
    Person p = new Student();

     Person p = new Student();
            String name2 = p.name;
            Integer age2 = p.age;
            p.sayGood();
            p.sayHello();
            System.out.println("Student类型转换 向上转型 打印 名字:"+name2+"年龄"+age2+"学号");
            //同时 这里的限定是 只能访问父类 类型里面的属性,不能访问子类特有的
    

    打印如下

    Student sayGood 名字:ling 年龄:24 学号:18599306
    sayHello 名字:ling 年龄:24
    Student类型转换 向上转型 打印 名字:ling年龄24学号
    

    可以看出,这时候父类引用变量已经可以访问自己被子类改造后的属性和方法.之所以访问不了子类特有的属性和方法,是因为我们之前提到的.引用类型变量,他有身份.他的身份就是他的类型.现在他的类型是Person类型,如果想要让他光明正大的访问子类类型特有属性和方法,那么需要加钱,哦,不!需要类型转换.转为Student类型.由于是从父类转化到子类所以称之为向下转型.

    3.向下转型

     Student s = (Student) p; //向下转型需要使用强制类型转换
            String name3 = s.name;
            Integer age3 = s.age;
            Integer studentNum1 = s.studentNum;
            s.sayHello();
            s.sayGood();
            s.doStudy();
            System.out.println("Person p 向下转型 名字:"+name3+"年龄"+age3+"学号"+studentNum1);
    

    打印如下

    sayHello 名字:ling 年龄:24
    Student sayGood 名字:ling 年龄:24 学号:18599306
    我是一名学生,我的爱好是喝花酒:ling 年龄:24 学号:18599306
    Person p 向下转型 名字:ling年龄24学号18599306
    

    由此可见,转型成为Student s后,s就可以愉快的访问各自私密信息啦啦啦啦.
    现在我们来回顾一下.
    1)使用父类类型,扩展性特别强,但是我们想访问被子类改造后的属性和方法,就需要向上转型.这个含义是 一个子类实例s0,被 一个父类引用变量Person p所指引了.本质上进行操作的还是子类实例s0,只不过遥控器的身份更加是父类引用.
    2)而当我们在此时,还是需要进一步访问子类实例s0的自身特殊属性和方法时候,那么我们需要把 刚刚s0这个实例对象,使用一个子类类型的引用变量Student s来进行操作,这样才可以访问到自身特殊的信息.而这个实例s0的引用变量从Person p到Student s的变化过程中,我们称之为向下转型.
    3)我们看到在这个过程中,实例对象自始至终都是s0本身,没有发生变化只是在创建后引用由一般默认的同级别的子类引用,变成了父类引用,向上造型.而从父类引用又变成子类引用.向下造型.
    4)那么我们思考,反过来可以吗?

    4.关于类型转换
    4.1 从大到小 or 从小到大

           Student s10 =new Student();
            Person p10 = new Person();
    
            boolean flag = p10 instanceof Student;
            //实际上之前的操作有些不那么严谨,在类型转换之前需要进行判断
            //如果可以就转,如果不能转,强转的话会出现运行异常,编译是没有问题的.
            // instanceof是Java中的二元运算符,左边是对象,右边是类;当对象是右边类或子类所创建对象时,返回true;否则,返回false。
            //只有flag为true的时候,才能把p10强转为Student类型.
            System.out.println("flag:"+flag);
            if(flag){
                s10= (Student) p10;  //强制类型转换 
                String name4 = s10.name;
                System.out.println("名字:"+name4);
            }
    

    打印如下

    flag:false
    

    由此可见,一个父类实例对象是不能把 引用变量变成子类引用变量的.相当于一个大胖子,试图把身上的衣服从大号的换成小号的.
    我们知道Java是人设计出来的东西,为何小转大可以,大转小就不可以呢,这里就要提到一个理论.
    里氏替换原则:在软件中将一个基类对象替换成它的子类对象,程序将不会产生任何错误和异常,反过来则不成立,如果一个软件实体使用的是一个子类对象的话,那么它不一定能够使用基类对象。
    例如:狗 田园犬
    我家里有一条田园犬,那么可以推断我家里有一条狗.
    反之,我家里有一条狗,不能推断出成我家里有一条田园犬.

    里氏代换原则是实现开闭原则的重要方式之一,由于使用基类对象的地方都可以使用子类对象,因此在程序中尽量使用基类类型来对对象进行定义,而在运行时再确定其子类类型,用子类对象来替换父类对象。

    展开全文
  • 向下转型:Cat cat = (Cat) a,必须要先经过向上转型的变量–再向下转型,此时cat就拥有子类自己定义的特有方法cat.sleep() instanceof用法:a instanceof Cat 这里a必须是经过向上转型后的父类对

    向上向下转型

    在这里插入图片描述

    定义一个父类Animals包含eat()方法、age初始值为0

    然后再定义两个子类:DogCat,都重写了eat()方法和age,然后再分别有自己的特有方法狗咆叫bark(),猫睡觉sleep()

    向上转型:Animals a = new Cat()

    向下转型:Cat cat = (Cat) a,必须要先经过向上转型的变量–再向下转型,此时cat就拥有子类自己定义的特有方法cat.sleep()

    instanceof用法:a instanceof Cat 这里a必须是经过向上转型后的父类对象,而Cat是继承父类的子类

    // 父类
    public class Animals {
        public int age = 0;
    
        public void eat(){
            System.out.println("Eat...");
        }
    }
    
    // 子类 继承 父类 Animals
    public class Dog extends Animals {
        public int age = 10;
    
        @Override
        public void eat(){
            System.out.println("eat bone...");
        }
    
        public void bark(){
            System.out.println("dog bark...");
        }
    }
    
    public class Cat extends Animals{
        public int age = 2;
        @Override
        public void eat(){
            System.out.println("eat fish...");
        }
    
        public void sleep(){
            System.out.println("cat sleep...");
        }
    }
    
    

    有一个宠物店AnimalsShop将宠物放入后,统计个数,以及可以取出该宠物

    public class AnimalsShop {
        // 注意这里用的Animals泛型,加入宠物时,不关心宠物的具体类型
        private List<Animals> list = new ArrayList<Animals>();
        // 当加入一个宠物时,相当于进行了向上转型
        public void add(Animals a){
            list.add(a);
        }
    
        public int getSize(){
            return list.size();
        }
        // 取出的宠物也是经过向上转型的,此时类型为Animals
        public Animals getAnimal(int position){
            return list.get(position);
        }
    }
    
    public static final int DOG = 0;
    public static final int CAT = 1;
        @Test
        public void test4(){
            // 通过泛型进行向上转型将不同类型的动物加入集合,此时不需要动物的不同特性,只需要知道个数即可
            AnimalsShop as = new AnimalsShop();
            as.add(new Dog());
            as.add(new Cat());
    
            // 获取动物个数
            System.out.println(as.getSize());
    
            // 查看所有的宠物
            Dog dog = (Dog) as.getAnimal(DOG); // 直接向下转型,并不安全,因为可以编译通过但运行出错
            dog.eat();
            dog.bark();
    
            Animals a = as.getAnimal(CAT);  // 获取已经向上转型Cat
            System.out.println(a instanceof Dog); // false,向上转型的Cat和Dog不构成子类关系
            // ((已经经过向上转型的)父类对象 instanceof 子类 ) 来判断是否可以向下转型更安全,防止ClassCastException转换异常
            if(a instanceof Cat){
                Cat cat = (Cat) as.getAnimal(CAT);
                cat.eat();
                cat.sleep();
            }
    
        }
    

    向下转型的最大好处是:java的泛型编程,用处很大,Java的集合类都是这样的。
    参考博客

    Java向下转型的意义

    Java对象类型向上转型

    多态的特点

    多态的前提:

    • 存在继承或实现接口extendimplement
    • 重写方法@Override
    • 父类引用指向子类对象Animals a = new Cat()

    多态的特点:

    • 相同变量看父类a.age = 0
    • 重写方法看子类eat()看子类
    • 子类特有方法不可用a.sleep()不可用
        public static void animalEat(Animals a){
            a.eat();
        }
    
        @Test
        public void test3(){
            Animals a1 = new Dog();
            System.out.println(a1.age); // 1. 变量看父类
            a1.eat(); // 2. 方法看子类
    //        a1.bark();  3. 子类特有不可用
    
            Animals a2 = new Cat();
            a2.eat();
    
            // 当向上转型后,通过一个通用方法调用不同的子类,即可实现子类的方法
            animalEat(new Dog());
            animalEat(new Cat());
        }
    
    展开全文
  • 简单理解Java中转型问题(向上转型和向下转型) —————————————————————————— 本文内容仅仅为个人的理解,仅供大家参考。如果本文中存在一些错误的地方还请大佬们指出,感激不尽。 ————...
  • 这种多态通过函数的重写以及向上转型来实现,我们上面代码中的例子就是一个完整的重写式多态。我们接下来讲的所有多态都是重写式多态,因为它才是面向对象编程中真正的多态。 动态绑定技术涉及到jvm,暂时不讲...
  • 比如Father fson = new Son(); 中, 情况1:fson调用函数funcA("haha"),这个函数在父类中有定义funcA(Object ...向上转型和静态绑定之间的关联又是什么呢???</p>
  • 在Java中有继承关系的类及接口中存在两种动作即向上转型和和向下转型,以更好地实现多态
  • Java对象类型转换:向上转型和向下转型 将一个类型强制转换成另一个类型的过程被称为类型转换。本节所说的对象类型转换,是指存在继承关系的对象,不是任意类型的对象。当对不存在继承关系的对象进行强制类型转换时...
  • 类的向上转型: 父类(包括抽象类)创建的引用类型变量可以调用子类对象 父类引用类型变量应用子类对象时,调用方法只能调用父类中出现过的方法,如果方法被重写,调用的是子类中重写的方法。 普通类示例 父类:...
  • 向上转型

    2018-06-06 17:07:54
    向上转型重新学习Java时看到j向上转型;public class Test01{ public static void main(String[] args){ System.out.println("Hellow"); Bird b = new Bird(); Panda p = new Panda(); Lion l = ...
  • * 向上转型:一定是安全的,但是一旦向上转型为父类,就无法调用子类特有的方法。从小范围转向大 * 范围,如从猫转型成动物。 * 描述: * 对象的向上转型就是多态 * 格式: * 父类名称 对象名 = new 子类名称...
  • 向上转型(隐式)   向上转型——用父类的引用变量去引用子类的实例(或者说子类对象给父类引用变量赋值),这是允许的。   向上转型之后,父类引用变量只能调用父类中的属性和方法,不能访问子类独有的属性和方法...
  • 对象的向上转型对象

    千次阅读 2019-03-17 17:00:31
    从人的思维方式来看,说“老虎时动物”属于上溯的思维方式,从而衍生出Java中的向上转型对象。 向上转型对象的声明 Animal a = new Tiger(); //或者 Animal a; Tiger b = new Tiger(); a = b; 这时,称对象a是...
  • } 上述代码中,调用run()方法时的参数不仅是Fruit对象,也可以是Apple对象和Orange对象,当传入的是Apple对象和Orange对象时,就会向上转型成Fruit对象,但是调用的show()方法还是Apple对象和Orange对象的show...
  • 向上转型的作用

    千次阅读 2019-08-10 17:02:10
    一、什么是向上转型 上转型对象不是父类创建的对象,而是子类对象的“简化”状态,它不关心子类新增的功能,只关心子类继承和重写的功能。 当一个类有很多子类时,并且这些子类都重写了父类中的某个方法。 当使用...
  • java对象转型(向上转型和向下转型)向下转型和向上转型是什么意思向上转型和向下转型的基本公式: 向下转型和向上转型是什么意思 基本数据类型,转换可以通过隐性和显性(强制)类型转换,例如float类型转成int类型...
  • 多态的向上转型: (1)本质:父类的引用指向了子类对象 (2)语法: 父类类型 引用名 = new 子类类型(); (3)特点(规则):编译类型看左边,运行类型看右边。 可以调用父类中的所有成员(遵守访问权限)(实际...
  • 向上转型 子类引用的对象转换为父类对象称为向上转型。 通俗地说就是将子类对象转为父类对象,此处父类对象可以是接口。 向上转型过程中需要注意的问题 1.向上转型时,子类单独定义的方法会丢失。 2.子类引用不能...
  • Java中的向上转型和向下转型

    千次阅读 2018-12-25 15:25:48
    什么是向上转型,向下转型 向上转型就是子类转化成父类,或接口 向下转型就是父类或接口 转化成子类 举个例子:人继承动物类,动物类有一个吃的技能,我们可以说人是动物,这就是向上转型 我们能说动物是人吗?不...
  • 从 2 个名词开始说起:向上转型(upcasting)、向下转型(downcasting)。 举个例子:有2个类,Father 是父类,Son 类继承自 Father。 第 1 个例子: Father f1 = new Son(); // 这就叫 upcasting (向上转型) // ...
  • 刚接触Java,关于多态下向上转型和向下转型,以及父类和子类的调用很混乱,看了一天资料,终于搞明白了 关于多态向上转型和向下转型的要点 一、向上转型后子类不能调用自己的私有属性和私有方法,只能调用父类...
  • 向上转型 向上转型在写代码的过程中经常会用到,它不仅是实现多态的重要机制,也是Java继承体系的精华体现。 向上转型常见的形式是:Person person = new Student();这里的Student类是Person类的子类,我们通过...

空空如也

空空如也

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

向上转型