精华内容
下载资源
问答
  • 2022-02-11 16:07:35

    编译类型(父类) 引用名=new 引用类型(子类)

    (1)可以调用父类中的所有成员(需遵守访问权限)

    (2)但不能调用子类特有的成员

    (3)在编译阶段,能调用那些成员,是由编译类型来决定的

    (4)最终运行效果看子类(运行类型)的具体实现,即调用方法时,按照从子类(运行类型)开始查找方法

    注:如果想要访问子类的特殊方法可以进行向下转型,即将父类的引用 强制转换成 子类类型

    子类类型 引用名 = (子类类型) 父类引用

    注意:

    向下转型时只能强转父类的引用,不能强转父类的对象

    要求父类的引用必须指向的是当前目标类型的对象

    强转完成之后就可以调用子类类型中的所有成员

    更多相关内容
  • 主要介绍了简单了解Java多态向上转型相关原理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 详细解析Java多态向上转型、向下转型

    1.什么是多态?

            多态是同一个行为具有多个不同表现形式或形态的能力。或者说:多态就是同一个接口,通过调用不同的实例执行不同操作。

            通俗的说:

                             多态就是“对于同一个消息的响应,不同对象响应结果不同”

        ---->>为帮助你更好的理解“多态”概念,下面举几个例子,一定要仔细思考:

            (1)举例1:

                    类1 ---->> Type1 :按 “年-月-日” 输出日期;

                    类2 ---->> Type2 :按 “月-日-年” 输出日期;

                    类3 ---->> Type3 :按 “日-月-年” 输出日期;

             当传递参数给Type1、Type2、Type3时,传入年、月、日参数,则对应三种不同的输出格式。也就是说:“年、月、日”是同一种数据,但是 “不同的 类” 对这一数据的响应结果不同,也就是所谓的“多态”。

            (2)举例2:

                    主函数中有以下语句:

                    int a = 123;
                    double d = (double)a;
                    byte b = (byte)a;//强制类型转换为byte
                    System.out.println("int强制类型转换为double后的值等于"+d);
                    System.out.println("int强制类型转换为byte后的值等于"+b);

            在这个例子中,对于同一 int 型数据a,分别强制转换为double、byte类型数据,这也带有多态的身影,即不同的语句对传递来的参数 a 响应结果不同,输出不同的数据,得到不同结果。

            (3)举例3:

                    打开电脑,不同情况下按下 F1 键:

                            如果当前在 Flash 界面下弹出的就是Falsh帮助;

                            如果当前在 Word 下弹出的就是 Word 帮助;

                            在 Windows 下弹出的就是 Windows 帮助和支持。

                    也就是说:同一个事件(按下F1键)发生在不同的对象上会产生不同的结果。

            (4)举例4:

               如下图片,打印机可以打印黑白的,也可以打印彩色的,这就是多态,命令传给“打印机”,但是“打印机对 命令的响应结果不同,从而 打印黑白或彩色样式”。

    2.多态优点

            消除类型之间的耦合关系、可替换性、可扩充性、接口性、灵活性、 简化性。

    3.实现多态的必要条件

            (1)继承:子类继承父类。

            (2)重写:在子类中重写从父类继承来的方法。

            (3)向上转型:即父类引用指向子类对象,如:Parent p = new Child()。

            下面根据下图具体举例说明:

            首先:

                    父类Shape中有draw()方法,分别创建Circle类、Triangle类、Square类作为子类继承(extends)父类Shape。Circle类、Triangle类、Square类 继承父类Shape 后,也分别含有了 从父类Shape中继承来的draw()方法。

            之后:

                    分别在Circle类、Triangle类、Square类 中对继承来的“ draw() 方法” 进行重写,使得不同 子类 中的draw() 方法实现不同功能,如下所示:

                    Circle类 中 draw() 方法 ---->> 实现 绘制 “圆”;

                    Triangle类 中 draw() 方法 ---->> 实现 绘制 “三角形”;

                    Square类  中 draw() 方法 ---->> 实现 绘制 “正方形”;

            当通过Shape s = new Circle() 或 Shape s = new Triangle() 、Shape s = new Square() 语句创建父类Shape对象 s 时,子类Circle、Triangle、Square 会自动“向上转型”到父类,之后父类引用会指向子类,从而调用不同子类中的draw()方法,实现不同功能,实现多态。

            上述  同时满足了“继承、重写、向上转型”三个条件从而实现了多态。

    4.代码实例测试

    //定义主类 Test,进行测试
    public class Test {
        public static void main(String[] args) {
          show(new Cat()); //用Cat对象初始化父类Animal并调用定义的show方法
          show(new Dog()); //用Dog对象初始化父类Animal并调用定义的show方法    
          Animal a = new Cat();//向上转型,Cat类对象初始化父类Animal 
          a.eat();//父类引用指向子类Cat,调用Cat类中的eat()方法
          Cat c = (Cat)a;//新建Cat类对象c,将对象a强制转换为Cat类对象,即向下转型  
          c.work();//向下转型后c为Cat类对象,调用的是Cat类中的work()方法
       }
    		
       //定义show函数      
       public static void show(Animal a)  {
          a.eat();  
            // 类型判断
            if (a instanceof Cat)  {  //是否是Cat类对象 
                Cat c = (Cat)a;//强制转换
                c.work(); 
            } else if (a instanceof Dog) { //是否是Dog类对象 
                Dog c = (Dog)a;//强制转换  
                c.work();  
            }  
       }  
    }
    
    //定义抽象类 Animal
    abstract class Animal {  
        abstract void eat();//抽象方法,无函数体
    }  
    
    //定义子类Cat,并继承父类Animal
    class Cat extends Animal { 
    	//实现父类中的 eat()方法
        public void eat() {  
            System.out.println("1.Cat eat()-->>>猫喜欢吃鱼");  
        }
    	//新增方法
        public void work() {  
            System.out.println("2.Cat work()-->>>猫的工作是抓老鼠");  
        }  
    }  
    
    //定义子类Dog,并继承父类Animal
    class Dog extends Animal { 
    	//实现父类中的 eat()方法
        public void eat() {  
            System.out.println("1.Dog eat()-->>>狗喜欢吃骨头");  
        }
    	//新增方法
        public void work() {  
            System.out.println("2.Dog work()-->>>狗的工作是看家");  
        }  
    }


    5.运行结果

    写在最后:

            如果仍有疑问可以留言哦。

    展开全文
  • //向上转型,Animal具有多态性质 (子类对象转为父类对象) Animal animal = new Cat ( ) ; //错误情况 //Cat cat = new Animal(); //调用的是Cat的eat方法 animal . eat ( ) ; //向...
    package com.up;
    
    public class Cat extends Animal{
    	
    	public void eat(){
    		System.out.println("吃鱼");
    	}
    	
    	
        public void work(){
        	System.out.println("抓老鼠");
        }
    
    }
    
    
    package com.up;
    
    public class Animal {
    	
    	public void eat(){
    		System.out.println("Animal eat");
    	}
    }
    
    
    
    package com.up;
    
    public class Main002 {
    	
    	public static void main(String[] args) {
    		//Animal没有多态的性质向下转型失败
    //		Animal animal = new Animal();
    //		Cat cat = (Cat)animal;
    		
    		//向上转型,Animal具有多态性质   (子类对象转为父类对象)
    		Animal animal = new Cat();
    		//错误情况
    		//Cat cat = new Animal();
    		
    		//调用的是Cat的eat方法
    		animal.eat();
    		
    		//向下转型  (父类对象转为子类对象)
    		Cat cat = (Cat)animal;
    		cat.work();
    	}
    
    }
    
    

    灵魂画手

    在这里插入图片描述

    展开全文
  • 首先,java多态是建立在java继承的基础上的,它表现的是同一种行为的不同表现形式,注意,是行为,即多态是java父子类中的方法的一个特性,而不是父子类中的属性的一个特性,比如: Person p1 = new Student(); ...

    首先,java多态是建立在java继承的基础上的,它表现的是同一种行为的不同表现形式,注意,是行为,即多态是java父子类中的方法的一个特性,而不是父子类中的属性的一个特性,比如:

     Person p1 = new Student();
        System.out.println(p1.age)
        //这里输出的就是父类中age属性的值
        
        p1.eat();
        //这里调用的是Student类中eat的方法,而不是Person类中的eat方法

    向上转型:

    什么是向上转型呢?向上转型是将子类对象地址赋值给父类对象使用,多态本身就是向上转型的,比如

    Person p1 = new Student();            父类 《— 子类

    new Student()开辟了一个新的子类对象空间,之后将这个新的子类对象空间的地址赋值给一个父类对象。

    向下转型:

    向下转型就是 子类 《—— 父类,也就是:

    Student p2 = (Student)p1;

    或者

    (Student) p1

    向下转型是因为当使用java多态时(以上述代码为例),p1只能调用父类Person中存在的方法,不能调用Student中新添加的方法,所以如果想通过多态来调用父类中没有的方法,可以用这样的方式

    (Student)p1.study();
    //study()方法是Student子类中新添加的方法,父类Person中没有

    向下转型要慎用,因为如果转型错误,在编译时并不会报错,但在运行时调用方法的时候会报错,这里java提供了一个双目运算符——instanceof 用来判断某个对象是否为某个类型,返回值为boolean,用法例子如下:

    Person p1 = new Student();  
    
            if(p1 instanceof Person){
                System.out.println("p1对象为Person类的一个实例");
            }
            if(p1 instanceof Student){
                System.out.println("p1对象为Student类的一个实例");
            }
    
            String s1 = "sfsd";
            if(s1 instanceof String){
                System.out.println("这是一个String类的对象");
            }

    运行结果如下:

    这里如果p1写成如下形式:

    Person p1 = new Person();
            if(p1 instanceof Person){
                System.out.println("p1对象为Person类的一个实例");
            }
            if(p1 instanceof Student){
                System.out.println("p1对象为Student类的一个实例");
            }

    结果如下: 

     

     

    展开全文
  • Java 多态 向上转型

    2018-04-01 14:05:13
    1.多态时成员变量的特点:正常情况下:package cn.interace.com; class fu{ //创建一个父类 int n=3; //定义父类中变量n=3 void show () { //定义父类的show方法 System.out.println("fu&...
  • 多态、、向上、向下转型,以及重写的解释
  • 向上转型 多态的作用 1.增加代码的复用性 2.便于代码的管理与维护 案例引入 代码: //测试类 public class Test { public static void main(String[] args) { Dog dog = new Dog("八嘎"); Bone bone = new...
  • Java多态——向上、向下转型
  • Java 向上转型的内存分析
  • Java - 向上转型与向下转型
  • //向上转型 父类引用指向子类对象 //语法: 父类对象 引用变量名 = new 子类对象 Pet pet = new Dog(); //Pet(第一个Pet):父类对象 //pet(第二个pet): 引用变量名 (随意起名) //Dog(): 子类对象 向上转型...
  • JAVA中的多态是类的固有属性,多态是由类的继承,重写,向上转型而产生的一种特质。举个例子我们创建一个叫程序员的class,这个class可以被很多class所继承,比如说前段程序员,后端程序员,数据库程序员等等。假如一...
  • Java多态 多态(Polymorphism)属于面向对象三大特征之一,它的前提是封装形成独立体,独立体之间存在继承关系,从而产生多态机制。多态是同一个行为具有多个不同表现形式或形态的能力。 现实中,比如我们按下 F1 键...
  • Java中,对于多态的核心表现主要有一下两点: 1.1 方法的多态性 ①. 方法的重载:同一个方法名称可以根据参数的类型或个数不同调用不同的方法体。   ②. 方法的覆写:同一个父类的方法,可能根据实例化子类的...
  • Java 多态 向上转型 向下转型
  • 其中尤其是向上转型,大概意思谁不懂啊,A a = new B() 嘛,然而往细了抠就有点蒙蔽,尤其是面对考卷里出现的那种贼JB恶心的多态题,简直要哭了。 翻阅了几篇大佬们写的博客,整理一下思路总结如下。 首先先从最...
  • java多态向上转型

    2021-06-12 08:46:01
    在本篇内容里小编给大家整理的是一篇关于java多态向上转型的概念及实例分析,对此有兴趣的朋友们可以跟着学习下。 1、说明 向上转型就是把一个子类引用给一个父类引用,也就是父类引用 引用了子类的对象,即...
  • 向上转型: 父类类型 变量名=new 子类类型(); //父类是animal,子类是cat Animal animal=new Cat(); 向下转型: 子类类型 变量名=(子类类型)父类变量名;(类似于强转) Cat c=(Cat) a; ...
  • 向上转型和向下转型 Person P = new SuperMan(); //向下转型 SuperMan sm = (SuperMan)P; //向上转型 sm.fly() 多态的好处和弊端 好处: 提高代码的维护性(继承保证)(在继承的类里面改一下就好了) 提高代码的...
  • 1、向上转型 父类的引用指向子类的对象 //女扮男装,由女儿变成了父亲的身份去征兵打仗 //向上转型,由小往大,自动转换 Daughter huaMuLan = new Daughter(); Father huaHu = huaMuLan; huaMuLan = null; ...
  • interface Animal { int a = 1; int eat(); } public class Test implements Animal{ public static void main(String[] args) { //向上转型 Animal animal = new Test();... //向上转型后可以
  • 将一个父类的引用指向一个子类的对象,称为向上转型(upcasting),自动进行类型转换。此时通过父类引用调用的方法是子类覆盖或继承父类的方法,不是父类的方法。 此时通过父类引用变量无法调用子类特有的方法; ...
  • Java多态中的向上转型和向下转型

    千次阅读 2018-08-01 20:04:29
    向上转型:将一个父类的引用指向一个子类对象,称为向上转型,自动进行类型转换  用法: Father f = new Son(); 向下转型:子类引用指向父类引用的子类对象 通俗的说就是子类实例对象赋值给父类引用,然后父类...
  • 1.向上转型 子—>父(自动类型转换) 2.向下转型 父—>子(强制类型转换,需要加强制类型转换符) 无论是向上转型,还是向下转型,两种类型之间必须有继承关系,没有继承关系编译器报错。 什么是多态? 编译的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,603
精华内容 11,041
关键字:

java多态向上转型

java 订阅