精华内容
下载资源
问答
  • Java如何实现多态
    千次阅读
    2021-02-12 10:24:44

    核心:

    1、多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编译时并不确定,而是在程序运行期间才确定,即一个引用变量倒底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类,这样,不用修改源程序代码,就可以让引用变量绑定到各种不同的类实现上,从而导致该引用调用的具体方法随之改变,即不修改程序代码就可以改变程序运行时所绑定的具体代码,让程序可以选择多个运行状态,这就是多态性。

    2、指向子类的父类引用由于向上转型了,它只能访问父类中拥有的方法和属性,而对于子类中存在而父类中不存在的方法,该引用是不能使用的,尽管是重载该方法。若子类重写了父类中的某些方法,在调用该些方法的时候,必定是使用子类中定义的这些方法(动态连接、动态调用)

    3、在继承链中对象方法的调用存在一个优先级:this.show(O)、super.show(O)、

    this.show((super)O)、super.show((super)O)。即先查this对象的父类,没有就重头再查参数的父类

    一、什么是多态面向对象的三大特性:封装、继承、多态

    多态的定义:指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)

    实现多态的技术称为:动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。

    多态的作用:消除类型之间的耦合关系。

    现实中,关于多态的例子不胜枚举。比方说按下 F1键这个动作,如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档;如果当前在 Word 下弹出的就是 Word 帮助;在Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。

    下面是多态存在的三个必要条件,要求大家做梦时都能背出来!

    多态存在的三个必要条件

    一、要有继承;

    二、要有重写;

    三、父类引用指向子类对象。

    二、多态的好处:

    1.可替换性(substitutability)。多态对已存在代码具有可替换性。例如,多态对圆Circle类工作,对其他任何圆形几何体,如圆环,也同样工作。

    2.可扩充性(extensibility)。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性,以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如,在实现了圆锥、半圆锥以及半球体的多态基础上,很容易增添球体类的多态性。

    3.接口性(interface-ability)。多态是超类通过方法签名,向子类提供了一个共同接口,由子类来完善或者覆盖它而实现的。如图8.3所示。图中超类Shape规定了两个实现多态的接口方法,computeArea()以及computeVolume()。子类,如Circle和Sphere为了实现多态,完善或者覆盖这两个接口方法。

    4.灵活性(flexibility)。它在应用中体现了灵活多样的操作,提高了使用效率。

    5.简化性(simplicity)。多态简化对应用软件的代码编写和修改过程,尤其在处理大量对象的运算和操作时,这个特点尤为突出和重要。

    Java中多态的实现方式:接口实现,继承父类进行方法重写,同一个类中进行方法重载。

    三、经典实例。

    public class A {

    public String show(D obj) {

    return ("A and D");

    }

    public String show(A obj) {

    return ("A and A");

    }

    }

    public class B extends A{

    public String show(B obj){

    return ("B and B");

    }

    public String show(A obj){

    return ("B and A");

    }

    }

    public class C extends B{

    }

    public class D extends B{

    }

    public class Test {

    public static void main(String[] args) {

    A a1 = new A();

    A a2 = new B();

    B b = new B();

    C c = new C();

    D d = new D();

    System.out.println("1--" + a1.show(b));

    System.out.println("2--" + a1.show(c));

    System.out.println("3--" + a1.show(d));

    System.out.println("4--" + a2.show(b)); //4--B and A .首先a2是A引用,B实例,调用show(B b)方法,此方法在父类A中没有定义,所以B中方法show(B b)不会调用(多态必须父类中已定义该方法),再按优先级为:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O),即先查this对象的父类,没有重头再查参数的父类。查找super.show((super)O)时,B中没有,再向上,找到A中show(A a),因此执行。

    System.out.println("5--" + a2.show(c)); //同上 System.out.println("6--" + a2.show(d)); //A and D .查找B中没有show(D d)方法,再查A中,有,执行。 System.out.println("7--" + b.show(b));

    System.out.println("8--" + b.show(c)); //B and B . System.out.println("9--" + b.show(d));

    }

    }

    运行结果:

    1--A and A

    2--A and A

    3--A and D

    4--B and A

    5--B and A

    6--A and D

    7--B and B

    8--B and B

    9--A and D

    来源:CSDN

    作者:JIAN_BOY_RISE

    声明:(本文二次转载,原文不可查)

    更多相关内容
  • Java多态的实现机制是什么Java实现多态的机制是依靠父类或接口的引用指向子类,从而实现一个对象多种形态的特性,其父类的引用是在运行时动态的指向具体的实例,调用该引用的方法时,不是根据引用变量的类型中定义...

    6103a013e933d18e1b9d70fb581416ea.png

    Java多态的实现机制是什么

    Java中实现多态的机制是依靠父类或接口的引用指向子类,从而实现一个对象多种形态的特性,其父类的引用是在运行时动态的指向具体的实例,调用该引用的方法时,不是根据引用变量的类型中定义的方法来运行,而是根据具体的实例的方法。

    简单的示例

    Person.javaimport java.util.Scanner;

    public class Person {

    public int salary;

    public int allSalary(){

    return 0;

    }

    public static void main(String[] args) {

    Person p = null;

    for (int n = 0; n < 3; n++) {

    @SuppressWarnings("resource")

    Scanner sc = new Scanner(System.in);

    System.out.println("请输入一个1-3的数字:\n1 is Teacher\n2 is Scientis\n3 is Waiter");

    int i = sc.nextInt();

    //分别指向了不同的子类,输出的结果是不一样的

    if (i == 1) {

    p = new Teacher(5000);

    System.out.println(p.allSalary());

    } else if (i == 2) {

    p = new Scientist(5000);

    System.out.println(p.allSalary());

    } else if (i == 3) {

    p = new Waiter(5000);

    System.out.println(p.allSalary());

    } else {

    System.out.println("?\n请输入1-3");

    }

    }

    }

    }

    Scientist .javapublic class Scientist extends Person{

    public Scientist(int salary){

    this.salary = salary;

    }

    public int allSalary(){

    int aa = salary*12+36500;

    System.out.print("五五开一年的工资:");

    return aa;

    }

    }

    Waiter.javapublic class Waiter extends Person{

    public Waiter(int salary){

    this.salary = salary;

    }

    public int allSalary(){

    int aa = salary*12;

    System.out.print("服务员一年的工资:");

    return aa;

    }

    }

    Teacher .javapublic class Teacher extends Person{

    public Teacher(int salary){

    this.salary = salary;

    }

    public int allSalary(){

    int aa = salary*12+3650;

    System.out.print("教师一年的工资:");

    return aa;

    }

    }

    推荐教程:《Java教程》

    展开全文
  • JAVA中多态性是对象多种表现形式的体现。在面向对象中,最常见的多态发生在使用父类的引用来引用子类的对象。下面这篇文章主要给大家介绍一下,需要的朋友可以参考下
  • 抽象类实现多态: 父类对象指向子类对象,可调用子类的重写方法。 接口实现多态: 接口对象指向实现类对象,可调用实现类的重写方法 以下就是生活中两种多态的实例,**抽象类是模板,接口是功能。 **描述: Door....

    抽象类实现多态:
    父类对象指向子类对象,可调用子类的重写方法。
    接口实现多态:
    接口对象指向实现类对象,可调用实现类的重写方法
    以下就是生活中两种多态的实例,**抽象类是模板,接口是功能。

    **描述:
    接口、抽象类实现多态图
    Door.java 抽象类

    package com.dialogd.polymorphic;
    //抽象类,抽象类是一种模板
    public abstract class Door {
    	//开门的方法
    	public abstract void open();
    }
    

    IFace.java 接口1

    package com.dialogd.polymorphic;
    //人脸识别的功能,接口是功能时
    public interface IFace {
    	//人脸识别的功能
    	public void checkFace();
    }
    

    IHander.java 接口2

    public interface IHander {
    	//指纹识别功能
    	public void checkHander();
    }
    

    SafeDoor.java

    public class SafeDoor extends Door implements IHander {
    
    	@Override
    	public void open() {
    		// TODO Auto-generated method stub
    		System.out.println("普通安全门开门...");
    	}
    
    	@Override
    	public void checkHander() {
    		// TODO Auto-generated method stub
    		System.out.println("普通安全门的指纹识别...");
    	}
    }
    

    SuperDoor.java

    public class SuperDoor extends Door implements IHander,IFace {
    
    	@Override
    	public void open() {
    		// TODO Auto-generated method stub
    		System.out.println("超级安全门开门...");
    	}
    
    	@Override
        	public void checkFace() {
        		// TODO Auto-generated method stub
        		System.out.println("超级防盗门的人脸识别...");
        	}
        
        	@Override
        	public void checkHander() {
        		// TODO Auto-generated method stub
        		System.out.println("超级防盗门的指纹识别...");
        	}
        
        }
    

    Test.java

    public class Test {
    	public static void main(String[] args) {
    		//抽象类实现多态
    		Door door = new SafeDoor();
    		//父类对象指向子类对象,可调用子类的重写方法
    		door.open();
    		door = new SuperDoor();
    		door.open();
    		
    
    		//接口实现多态
    		IHander iHander = new SafeDoor();
    		//接口对象指向实现类对象,可调用实现类的重写方法
    		iHander.checkHander();     
    		
    		iHander = new SuperDoor();
    		iHander.checkHander();
    		IFace iFace = new SuperDoor();
    		iFace.checkFace();
    	}
    }
    

    抽象类Door.java对子类(普通安全门)SafeDoor.java、(超级安全门)SuperDoor.java实现了多态。
    接口IHander、IFace对是实现类SafeDoor.java、SuperDoor.java实现了多态。

    展开全文
  • java实现多态的方式

    2021-03-06 04:02:30
    Java实现多态的方式:1、接口实现;2、继承父类进行方法重写;3、同一个类中进行方法重载。多态存在的必要条件:1、要有继承;2、要有重写;3、父类引用指向子类对象。多态的好处:1、可替换性(substitutability)...

    8d70b407230a2198e60078409930791e.png

    Java中实现多态的方式:

    1、接口实现;

    2、继承父类进行方法重写;

    3、同一个类中进行方法重载。

    多态存在的必要条件:

    1、要有继承;

    2、要有重写;

    3、父类引用指向子类对象。

    多态的好处:

    1、可替换性(substitutability)。

    多态对已存在代码具有可替换性。例如,多态对圆Circle类工作,对其他任何圆形几何体,如圆环,也同样工作。

    2、可扩充性(extensibility)。

    多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性,以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如,在实现了圆锥、半圆锥以及半球体的多态基础上,很容易增添球体类的多态性。

    3、接口性(interface-ability)。

    多态是超类通过方法签名,向子类提供了一个共同接口,由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法,computeArea()以及computeVolume()。子类,如Circle和Sphere为了实现多态,完善或者覆盖这两个接口方法。

    4、灵活性(flexibility)。

    它在应用中体现了灵活多样的操作,提高了使用效率。

    5、简化性(simplicity)。

    多态简化对应用软件的代码编写和修改过程,尤其在处理大量对象的运算和操作时,这个特点尤为突出和重要。

    多态实例:

    (1)相关类class A ...{

    public String show(D obj)...{

    return ("A and D");

    }

    public String show(A obj)...{

    return ("A and A");

    }

    }

    class B extends A...{

    public String show(B obj)...{

    return ("B and B");

    }

    public String show(A obj)...{

    return ("B and A");

    }

    }

    class C extends B...{}

    class D extends B...{}

    (2)问题:以下输出结果是什么?A a1 = new A();

    A a2 = new B();

    B b = new B();

    C c = new C();

    D d = new D();

    System.out.println(a1.show(b)); ①

    System.out.println(a1.show(c)); ②

    System.out.println(a1.show(d)); ③

    System.out.println(a2.show(b)); ④

    System.out.println(a2.show(c)); ⑤

    System.out.println(a2.show(d)); ⑥

    System.out.println(b.show(b)); ⑦

    System.out.println(b.show(c)); ⑧

    System.out.println(b.show(d)); ⑨

    (3)答案① A and A

    ② A and A

    ③ A and D

    ④ B and A

    ⑤ B and A

    ⑥ A and D

    ⑦ B and B

    ⑧ B and B

    ⑨ A and D

    展开全文
  • 这样就可以不用修改源程序,就可以让引用变量绑定到各种不同的类实现上,Java实现多态有三个必要条件:继承、重定、向上转型,在多态中需要将子类的引用赋值给父类对象,只有这样该引用才能够具备调用父类方法和子类...
  • 关于java实现多态的文章早已是非常多了,本文是对我个人过往学习java,理解及应用java实现多态的一个总结。此文内容涉及多态的基本概念,以及java中实现多态的方式,希望对大家有所帮助。 java怎么实现多态? Java...
  • Java 如何实现多态

    2020-03-31 13:58:26
    实现多态有三个前提条件 1、 继承的存在;(继承是多态的基础,没有继承就没有多态)。 2、子类重写父类的方法。(多态下会调用子类重写后的方法)。 3、父类引用变量指向子类对象。(涉及子类到父类的类型转换)。 ...
  • 本质上多态分两种: 1.编译时多态(compile-time polymorphism) /(static polymorphism ) 重载(overload) public class TextFileStaticPolymorphism { public String read() { return ...
  • 今天小千就来给大家介绍一下什么多java多态和java如何实现多态。 什么是多态? 指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用) ...
  • Java多态实现机制

    2011-04-14 23:33:33
    Java多态实现机制,多态java的三大属性之一,开发中很重要的一个环节
  • 什么是多态JAVA多态 方法必须要被所在类或对象调用才有意义 若方法含有参数: 形参:方法声明时的参数。 实参:方法调用时实际传给形参的参数值。 JAVA里将实参数值传入方法的传递机制只有 值传递 在值...
  • java是如何实现多态

    2021-03-01 08:33:58
    多态就是指一个引用变量倒底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。 (推荐学习:java课程)因为在程序运行时才确定具体的类,这样,不用修改源...
  • 主要介绍了Java中多态性的实现方式,什么是多态?通过简单的一道题目帮大家理解java多态性,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Java多态实现原理

    多人点赞 2021-06-03 16:06:38
    多态Java语言重要的特性之一,它允许基类的指针或引用指向派生类的对象,而在具体访问时实现方法的动态绑定。Java对于方法调用动态绑定的实现主要依赖于方法表,但通过引用调用(invokevitual)和接口引用调用...
  • Java 多态实现原理

    2021-02-27 19:49:57
    1、多态的机制1.1 本质上多态分两种1、编译时多态(又称静态多态)2、运行时多态(又称动态多态)重载(overload 发生在一个类中,方法名必须相同,不同参数)就是编译时多态的一个例子,编译时多态在编译时就已经确定,...
  • Java实现多态的机制是什么?

    万次阅读 多人点赞 2019-05-07 23:26:06
    多态就是指一个引用变量倒底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。 因为在程序运行时才确定具体的类,这样,不用修改源程序代码,就可以让...
  • 多态是方法的多态,不是属性的多态(多态与属性无关)2.多态存在要有3个必要条件:继承、方法重写、父类引用指向子类对象。3.父类引用指向子类对象后,用该父类引用调用子类重写的方法,此时多态就出现了。案例代码:...
  •    八、向上转型实现多态    九、多态的优缺点 前言   多态,多态,多态到底是一个什么样的定义呢,充满着好奇心,决定去研究一番。 多态(Polymorphism)的基本概念   多态意味着父类的变量可以指向子类...
  • 1、多态的机制1.1 本质上多态分两种1、编译时多态(又称静态多态)2、运行时多态(又称动态多态)重载(overload 发生在一个类中,方法名必须相同,不同参数)就是编译时多态的一个例子,编译时多态在编译时就已经确定,...
  • Java 的接口public interface 类名接口是Java方法的合集,用于给不同的类实现同名的方法,接口是一个只有抽象方法的抽象类,1、接口中可以定义变量,但是变量必须有固定的修饰符修饰,public static final所以接口中...
  • java实现的方式也是比较多的,今天主要介绍的是多态实现接口的主要做法,一起来了解一下吧。多态实现方式:实现接口相比而言就更加复杂,原因在于,Java的单继承保证了类的线性关系,而接口可以同时实现多个,...
  • Java 语言中,多态主要有以下两种表现方式: 1)方法的重载(overload)。重载是指同一个类中有多个同名的方法,但这些方法有着不同的参数,因此在编译时就可以确定到底调用哪个方法,它是一种编译时多态。重载可以...
  • 多态的概念 * 一个事物在不同时刻的体现(堆内存中对象形式) * 多态的前提条件: * 1)必须有继承关系(继承的好处第三点作为多态的前提条件) * 如果没有继承谈不上多态 * 2)方法重写,子类继承父类,将父类的...
  • Java多态实现原理

    千次阅读 2021-08-26 16:59:08
    这里的接口不应理解得太死板,比如在 Java 里面,继承一个类和实现一个接口本质上都是一种继承行为,因此都可以理解为多态的体现。 从静态和动态的角度进行划分,多态可以分为编译时多态和运行时多态。 编译时多态...
  • 上次已经为大家介绍过java多态的意义是什么的主要内容了。今天为大家解析一下java多态的机制,会通过实际的代码来为大家解析,一起来了解一下吧。首先说一些,多态的机制本质上多态分两种:1. 编译时多态(又称...
  • java多态实现机制

    2021-02-28 14:25:54
    Java提供了编译时多态和运行时多态两种多态机制。前者是通过方法重载实现的,后者是通过方法的覆盖实现的。在方法覆盖中,子类可以覆盖父类的方法,因此同类的方法会在父类与子类中有着不同的表现形式。在Java语言中...
  • 在理解什么是多态之前,我们要先来知道几个概念,首先我们要知道什么叫向上转型。 向上转型顾名思义,把子类转型成父类,简单说就是用父类的引用引用子类的对象 它有以下三种表现形式: 直接赋值 方法的...
  • 是什么在Java多态存在的必要条件发布时间:2020-07-15 15:48:37来源:亿速云阅读:106作者:Leah本篇文章给大家分享的是有关是什么在Java多态存在的必要条件,小编觉得挺实用的,因此分享给大家学习,希望大家...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 180,939
精华内容 72,375
关键字:

java如何实现多态

java 订阅