精华内容
下载资源
问答
  • 主要介绍了简单了解Java多态向上转型相关原理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 多态的定义与使用格式多态的定义格式:就是父类的引用变量指向子类对象父类类型 变量名 = new 子类类型();变量名.方法名();普通类多态定义的格式父类 变量名 = new 子类();如: class Fu {}class Zi extends Fu {}//...

    多态的定义与使用格式

    多态的定义格式:就是父类的引用变量指向子类对象

    父类类型  变量名 = new 子类类型();

    变量名.方法名();

    普通类多态定义的格式

    父类 变量名 = new 子类();

    如: class Fu {}

    class Zi extends Fu {}

    //类的多态使用

    Fu f = new Zi();

    式抽象类多态定义的格

    抽象类 变量名 = new 抽象类子类();

    如: abstract class Fu {

    public abstract void method();

    }

    class Zi extends Fu {

    public void method(){

    System.out.println(“重写父类抽象方法”);

    }

    }

    //类的多态使用

    Fu fu= new Zi();

    接口多态定义的格式

    接口 变量名 = new 接口实现类();

    如: interface Fu {

    public abstract void method();

    }

    class Zi implements Fu {

    public void method(){

    System.out.println(“重写接口抽象方法”);

    }

    }

    //接口的多态使用

    Fu fu = new Zi();

    注意事项

    同一个父类的方法会被不同的子类重写。在调用方法时,调用的为各个子类重写后的方法。

    如 Person p1 = new Student();

    Person p2 = new Teacher();

    p1.work(); //p1会调用Student类中重写的work方法

    p2.work(); //p2会调用Teacher类中重写的work方法

    当变量名指向不同的子类对象时,由于每个子类重写父类方法的内容不同,所以会调用不同的方法。

    public classPerson {public voideat() {

    System.out.println("人吃饭");

    }

    }

    public class Student extendsPerson{public voideat() {

    System.out.println("学生吃饭");

    }

    }

    public abstract classAnimal {public abstract voidsleep() ;

    }

    public class Cat extendsAnimal{public voidsleep() {

    System.out.println("猫趴着睡觉");

    }

    }

    public interfaceDrinking {public abstract voiddrink();

    }

    public class Pig implementsDrinking{public voiddrink() {

    System.out.println("小猪喝酒");

    }

    }

    public classDemo01 {public static voidmain(String[] args) {//1.多态:子类对象指向父类引用变量(普通类之间的多态)

    Person p=newStudent();

    p.eat();//2.抽象类与普通类的多态(抽象类可利用多态创建普通对象)

    Animal a=newCat();

    a.sleep();//3.接口与普通类之间的多态(子类必须是普通类)

    Drinking d=newPig();

    d.drink();

    }

    }

    展开全文
  • 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.多态时成员变量的特点:

    正常情况下:

    package cn.interace.com;

     class fu{ //创建一个父类
    int n=3; //定义父类中变量n=3
    void show () { //定义父类的show方法
    System.out.println("fu");
    }
     
     }
     class zi extends fu{ //创建一个子类
    int n=4; //定义子类中变量n=4
    void show (){ //重写父类的show方法
    System.out.println("zi");
    }
     }
    public class inhertDemo {


    public static void main(String[] args) {
    // TODO Auto-generated method stub
    zi z = new zi(); //创建子类的对象
    System.out.println(z.n);

    }


    }

    输出为4

    如果其他不变只把主函数里面的创建对象向上转型


    输出结果为3

    如果我们把父类中的n注释掉,就会报错。



    所以多态时成员变量在编译时:参考引用类型中是否有调用的成员变量,若有则编译通过否则编译失败

    运行时参考引用类型中是否有调用的成员变量,并运行所属类中的成员变量

    其实再简单一点就是:以等号左边的为基准就行了

    向上转型就是把子类提升为父类,此时创建的对象只有父类的属性,子类特有的属性没有。

    fu z =new zi();相当于int a; float b=a;

    2.多态时成员方法的特点:

    正常情况下:
    package cn.interace.com;
     class fu{ //创建一个父类
    void show () { //定义父类的show方法
    System.out.println("fu");
    }
     
     }
     class zi extends fu{ //创建一个子类
    void show (){ //重写父类的show方法
    System.out.println("zi");
    }
     }
    public class inhertDemo {


    public static void main(String[] args) {
    // TODO Auto-generated method stub
    zi z = new zi();
    z.show();
    }


    }

    输出的是子类的方法

    在多态时,如果创建对象向上转型

    即:


    那么,这个函数调用该怎么运行?

    首先,编译时以等号左边为主,找到父类的show方法则编译通过,如果没有就会出错

    运行时由 fu z = new zi(); (类似于 zi z = new  zi();)可知z指向子类的地址空间,所以z.show();调用的是子类的方法,如果子类没有则去父类中查找。

    简单地说:编译看左边,运行看右边。

    2.多态时静态成员方法的特点:

    先上例子和代码

    package cn.interace.com;
     class fu{ //创建一个父类
    static void meth() {
    System.out.println("fu static");
    }
    void show () { //定义父类的show方法
    System.out.println("fu");
    }
     
     }
     class zi extends fu{ //创建一个子类
    static void meth() {
    System.out.println("zi static");
    }
    void show (){ //重写父类的show方法
    System.out.println("zi");
    }
     }
    public class inhertDemo {


    public static void main(String[] args) {
    // TODO Auto-generated method stub
    fu z = new zi();
    //z.show();
    z.meth();
    }


    }

    运行结果为


    首先,先简单说一下,为什么非静态就是调用子类的方法,因为非静态运行看的是对象,静态直接被类名调用

    所以多态时静态函数编译和运行都看左边,其实静态方法根本不需要对象,直接类名调用即可。

    展开全文
  • 一、什么是多态?举例说明如下:public class Animal{//成员public void eat(){System.out.println("动物在吃!");}}public class Cat extends Animal{//重写public void eat(){System.out.println("猫吃鱼");}//Cat...

    一、什么是多态?

    举例说明如下:

    public class Animal{

    //成员

    public void eat(){

    System.out.println("动物在吃!");

    }

    }

    public class Cat extends Animal{

    //重写

    public void eat(){

    System.out.println("猫吃鱼");

    }

    //Cat特有的方法.

    public void move(){

    System.out.println("猫走猫步!");

    }

    }

    public class Dog extends Animal{

    //重写

    public void eat(){

    System.out.println("狗啃骨头!");

    }

    }

    public class Test{

    public static void main(String[] args){

    //向上转型又被称作:自动类型转换.

    //父类型的引用指向子类型对象.

    //程序分两个阶段:编译阶段,运行阶段。

    //程序编译阶段只知道a1是一个Animal类型。

    //程序在运行的时候堆中的实际对象是Cat类型。

    Animal a1 = new Cat();

    //程序在编译阶段a1被编译器看做Animal类型.

    //所以程序在编译阶段a1引用绑定的是Animal类中的eat方法.(静态绑定)

    //程序在运行的时候堆中的对象实际上是Cat类型,而Cat已经重写了eat方法。

    //所以程序在运行阶段对象的绑定的方法是Cat中的eat方法.(动态绑定)

    a1.eat(); //猫吃鱼

    //向下转型:强制类型转换

    Animal a2 = new Cat(); //向上转型.

    //要执行move方法,怎么做?

    //只能强制类型转换,需要加强制类型转换符

    Cat c1 = (Cat)a2;

    c1.move();

    //判断以下程序运行的时候会出什么问题?

    //Animal a3 = new Dog(); //向上转型.

    //强制类型转换

    //Cat c2 = (Cat)a3; //会抛出异常: java.lang.ClassCastException

    //在做强制类型转换的时候程序是存在风险的!

    //为了避免ClassCastException的发生,java引入了 instanceof

    用法:

    1. instanceof运算符的运算结果是 boolean类型

    2. (引用 instanceof 类型) --> true/false

    例如:(a instanceof Cat) 如果结果是true表示:a引用指向堆中的java对象是Cat类型.

    Animal a3 = new Dog();

    System.out.println(a3 instanceof Cat); //结果是:false

    //推荐:在做向下转型的时候要使用instanceof运算符判断,避免ClassCastException

    if(a3 instanceof Cat){

    Cat c2 = (Cat)a3;

    }

    }

    }

    关于java语言中向上转型和向下转型

    1.向上转型(upcasting) :  子--->父

    2.向下转型(downcasting) :  父--->子

    注意:无论是向上转型还是向下转型,两个类之间必须要有继承关系。

    public class Test{

    public static void main(String[] args){

    //向上转型又被称作:自动类型转换.

    //父类型的引用指向子类型对象.

    //程序分两个阶段:编译阶段,运行阶段。

    //程序编译阶段只知道a1是一个Animal类型。

    //程序在运行的时候堆中的实际对象是Cat类型。

    Animal a1 = new Cat();

    //程序在编译阶段a1被编译器看做Animal类型.

    //所以程序在编译阶段a1引用绑定的是Animal类中的eat方法.(静态绑定)

    //程序在运行的时候堆中的对象实际上是Cat类型,而Cat已经重写了eat方法。

    //所以程序在运行阶段对象的绑定的方法是Cat中的eat方法.(动态绑定)

    a1.eat(); //猫吃鱼

    //向下转型:强制类型转换

    Animal a2 = new Cat(); //向上转型.

    //要执行move方法,怎么做?

    //只能强制类型转换,需要加强制类型转换符

    Cat c1 = (Cat)a2;

    c1.move();

    //判断以下程序运行的时候会出什么问题?

    //Animal a3 = new Dog(); //向上转型.

    //强制类型转换

    //Cat c2 = (Cat)a3; //会抛出异常: java.lang.ClassCastException

    //在做强制类型转换的时候程序是存在风险的!

    //为了避免ClassCastException的发生,java引入了 instanceof

    用法:

    1. instanceof运算符的运算结果是 boolean类型

    2. (引用 instanceof 类型) --> true/false

    例如:(a instanceof Cat) 如果结果是true表示:a引用指向堆中的java对象是Cat类型.

    Animal a3 = new Dog();

    System.out.println(a3 instanceof Cat); //结果是:false

    //推荐:在做向下转型的时候要使用instanceof运算符判断,避免ClassCastException

    if(a3 instanceof Cat){

    Cat c2 = (Cat)a3;

    }

    }

    } 二、多态的好处 1.使用多态可以使代码之间的耦合度降低。 2.项目的扩展能力增强。

    展开全文
  • 向上转型:符合“is a”,是安全的,子类向上到父类,多余的属性和方法会丢弃向下转型:不安全的,用instanceof提前判断一下,以免抛出异常instanceof用法:result = object instanceof classresult:布尔类型object...

    向上转型:符合“is a”,是安全的,子类向上到父类,多余的属性和方法会丢弃

    向下转型:不安全的,用instanceof提前判断一下,以免抛出异常

    instanceof用法:

    result = object instanceof class

    result:布尔类型

    object:必选项,任意对象表达式

    class:必选项,任意已定义的对象类

    说明: 如果object是class或者其子类的一个实例,则instanceof运算符返回true,如果不是或者object是null,则返回false

    public class AnimalDemo {

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    Animal animal1 = new Dog("旺财");//向上转型

    Animal animal2 = new Cat("招财猫");

    animal1.eat();

    //animal1.sleep();因为向上转型,所以子类的sleep()丢弃了

    //父类的引用变量只能调用父类中有的方法,或者是子类重写父类的方法

    animal2.eat();

    //向下转型不安全,需要提前用instanceof判断一下,防止异常抛出

    if(animal2 instanceof Cat){

    System.out.println("111");

    Cat cat = (Cat)animal2;

    cat.sleep();

    }

    }

    }

    class Animal{

    private String name;

    public Animal(String name) {

    this.name = name;

    }

    public void eat() {//子类要重写

    System.out.println(name);

    }

    }

    class Dog extends Animal{

    public Dog(String name) {

    super(name);

    }

    public void eat() {

    System.out.println("吃狗粮");

    }

    public void sleep() {

    System.out.println("sleep");

    }

    }

    class Cat extends Animal{

    public Cat(String name) {

    super(name);

    }

    public void eat() {

    System.out.println("吃猫粮");

    }

    public void sleep() {

    System.out.println("sleep");

    }

    }

    展开全文
  • 这篇文章主要介绍了简单了解Java多态向上转型相关原理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下多态性是面向对象的第三大特征。多态的优点改善代码的组织...
  • java 向上转型和向下转型 学习向上转型和向下转型怎么用没多难,但是为什么那样用,我搞了很多次没弄明白。没弄明白的原因是平时学习时之看例子,而例子一般都比较简单,没有对象之间的调用,一般就是一个对象调用...
  • 向上转型: 父类类型 变量名=new 子类类型(); //父类是animal,子类是cat Animal animal=new Cat(); 向下转型: 子类类型 变量名=(子类类型)父类变量名;(类似于强转) Cat c=(Cat) a; ...
  • 封装、继承、多态是面向对象的三大特征,在Java中什么是多态Java引用变量有两种类型,分别是编译时类型和运行时类型。何为编译时类型,编译时类型就是由声明该变量时使用的类型决定,而运行时类型是由...
  • //向上转型,Animal具有多态性质 (子类对象转为父类对象) Animal animal = new Cat ( ) ; //错误情况 //Cat cat = new Animal(); //调用的是Cat的eat方法 animal . eat ( ) ; //向...
  • interface Animal { int a = 1; int eat(); } public class Test implements Animal{ public static void main(String[] args) { //向上转型 Animal animal = new Test();... //向上转型后可以
  • 多态 向上转型 向下转型 抽象类 抽象方法 类与接口的关系 匿名内部类 身边很多同学都说多态这部分是学java过程中遇到的第一个难点,里面很多抽象的内容很难理解。感觉这块还是得多看概念,不是所有代码学习都能只用...
  • 假定Base b = new Derived(); 调用执行b.methodOne()后,输出结果是什么? 题目: public class Base { public void methodOne() { System.out.print("A"); methodTwo(); } public void methodTwo()... ...
  • 初识JAVA-多态向上转型与向下转型 多态: 程序定义的引用变量所指向的具体的类和通过该变量发出的方法调用,在编程时并不确定,在程序运行时期间才被确定。 条件: 1.首先要有继承或接口的实现 2.子类要对父类的方法...
  • Java多态向上转型

    2019-12-18 14:05:14
    文章目录Java多态向上转型多态的优点向上转型概念向上转型好在哪 Java多态向上转型 多态性是面向对象的第三大特征。 多态的优点 改善代码的组织结构和可读性。 能够创建可扩展的程序。(随时可以加入新功能) ...
  • A:向上转型:当有子类对象赋值给一个父类引用时,便是向上转型多态本身就是向上转型的过程。 使用格式:父类类型 变量名 = new 子类类型();如:Person p = new Student(); B:向下转型:一个已...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,038
精华内容 815
关键字:

java多态向上转型

java 订阅