精华内容
下载资源
问答
  • Java中的多态什么多态? 多态性是面向对象编程的三大重要特征之一,它是指在父类中定义的属性和方法被子类继承之后,可以具有不同的数据类型或表现出不同的行为,这使得同一个属性或方法在父类及其各个子类中...

    Java中的多态:什么是多态?

    多态性是面向对象编程的三大重要特征之一,它是指在父类中定义的属性和方法被子类继承之后,可以具有不同的数据类型或表现出不同的行为,这使得同一个属性或方法在父类及其各个子类中具有不同的含义。

    对面向对象来说,多态分为编译时多态和运行时多态。 其中编译时多态是静态的,主要是指方法的重载,它是根据参数列表的不同来区分不同的方法。通过编译之后会变成两个不同的方法,在运行时谈不上多态。而运行时多态是动态的,它是通过动态绑定来实现的,也就是大家通常所说的多态性。

    Java实现多态有 3 个必要条件:继承、重写、父类(或接口)的引用指向子类对象(向上转型)。

    • 继承:在多态中必须存在有继承关系的子类和父类。
    • 重写:子类对父类中某些方法进行重新定义,在调用这些方法时就会调用子类的方法。
    • 向上转型:在多态中需要将父类引用指向子类对象,只有这样该引用才既能可以调用父类的方法,又能调用子类的方法。

    下面通过一个例子来演示重写如何实现多态性。例子使用了类的继承和运行时多态机制,具体步骤如下。

    1)创建 Figure 类,在该类中首先定义存储二维对象的尺寸,然后定义有两个参数的构造方法,最后添加 area() 方法,该方法计算对象的面积。代码如下:

    public class Figure {
        double dim1;
        double dim2;
        Figure(double d1, double d2) {
            // 有参的构造方法
            this.dim1 = d1;
            this.dim2 = d2;
        }
        double area() {
            // 用于计算对象的面积
            System.out.println("父类中计算对象面积的方法,没有实际意义,需要在子类中重写。");
            return 0;
        }
    }
    

    2)创建继承自 Figure 类的 Rectangle 子类,该类调用父类的构造方法,并且重写父类中的 area() 方法。代码如下:

    public class Rectangle extends Figure {
        Rectangle(double d1, double d2) {
            super(d1, d2);
        }
        double area() {
            System.out.println("长方形的面积:");
            return super.dim1 * super.dim2;
        }
    }
    

    3)创建继承自 Figure 类的 Triangle 子类,该类与 Rectangle 相似。代码如下:

    public class Triangle extends Figure {
        Triangle(double d1, double d2) {
            super(d1, d2);
        }
        double area() {
            System.out.println("三角形的面积:");
            return super.dim1 * super.dim2 / 2;
        }
    }
    

    4)创建 Test 测试类,在该类的 main() 方法中首先声明 Figure 类的变量 figure,然后分别为 figure 变量指定不同的对象,并调用这些对象的 area() 方法。代码如下:

    public class Test {
        public static void main(String[] args) {
            Figure figure; // 声明Figure类的变量
            figure = new Rectangle(9, 9);
            System.out.println(figure.area());
            System.out.println("===============================");
            figure = new Triangle(6, 8);
            System.out.println(figure.area());
            System.out.println("===============================");
            figure = new Figure(10, 10);
            System.out.println(figure.area());
        }
    }
    

    从上述代码可以发现,无论 figure 变量的对象是 Rectangle 还是 Triangle,它们都是 Figure 类的子类,因此可以向上转型为该类,从而实现多态。

    5)执行上述代码,输出结果如下:

    长方形的面积:
    81.0
    ===============================
    三角形的面积:
    24.0
    ===============================
    父类中计算对象面积的方法,没有实际意义,需要在子类中重写。
    0.0
    
    展开全文
  • 尤其是java多态的原理也是很深厚的,一起来了解一下吧。首先我们需要知道的是,多态是面向对象编程语言的重要特性,它允许基类的指针或引用指向派生类的对象,而在具体访问时实现方法的动态绑定。Java对于方法调用...

    想要学习java知识,就必须要做好长期奋战的准备,因为java的内容是非常丰富的,而且涉及的范围非常广阔。尤其是java多态的原理也是很深厚的,一起来了解一下吧。

    首先我们需要知道的是,多态是面向对象编程语言的重要特性,它允许基类的指针或引用指向派生类的对象,而在具体访问时实现方法的动态绑定。

    Java对于方法调用动态绑定的实现主要依赖于方法表,但通过类引用调用(invokevitual)和接口引用调用(invokeinterface)的实现则有所不同。

    另外,类引用调用的大致过程为:Java编译器将Java源代码编译成class文件,在编译过程中,会根据静态类型将调用的符号引用写到class文件中。

    在执行时,JVM根据class文件找到调用方法的符号引用,然后在静态类型的方法表中找到偏移量,然后根据this指针确定对象的实际类型,使用实际类型的方法表,偏移量跟静态类型中方法表的偏移量一样,如果在实际类型的方法表中找到该方法,则直接调用,否则,认为没有重写父类该方法。按照继承关系从下往上搜索。

    具体如下图所示:

    ea2b727bc5d28a25e6a2149e0eca3ecd.png

    从上图可以看出,当程序运行时,需要某个类时,类载入子系统会将相应的class文件载入到JVM中,并在内部建立该类的类型信息(这个类型信息其实就是class文件在JVM中存储的一种数据结构),包含java类定义的所有信息,包括方法代码,类变量、成员变量、以及方法表。这个类型信息就存储在方法区。

    需要注意的是,这个方法区中的类型信息跟在堆中存放的class对象是不同的。在方法区中,这个class的类型信息只有唯一的实例(所以是各个线程共享的内存区域),而在堆中可以有多个该class对象。可以通过堆中的class对象访问到方法区中类型信息。就像在java反射机制那样,通过class对象可以访问到该类的所有信息一样。

    以上就是关于java多态原理的主要内容了,并且为大家详细的解析出来了,可以看出主要的知识还是比较好理解的。如果你想要了解更多的java基础知识和常见问题,敬请关注奇Q工具网。

    推荐阅读:

    展开全文
  • java 多态什么

    2020-12-22 17:10:27
    多态是同一个行为具有多个不同表现形式或形态的能力。 多态的优点 消除类型之间的耦合关系:在使用重载方式,来对同方法名不同参数类型,来达到不同结果,进而消除了一定耦合关系 可替换性:在使用重写方式,完全...

    多态,java 三大特性之一
    多态是同一个行为具有多个不同表现形式或形态的能力。

    多态的优点

    1. 消除类型之间的耦合关系:在使用重载方式,来对同方法名不同参数类型,来达到不同结果,进而消除了一定耦合关系
    2. 可替换性:在使用重写方式,完全可以替换覆盖父类同方法名方法逻辑
    3. 可扩充性:使用重写或重载,可以达到扩充新需求的目的
    4. 接口性:主要是接口类继承实现方式,相当于一个接口,多个方法;
    5. 灵活性:灵活就是在于继承方式的重写和方法重载编写方式;还有就是接口的使用
    6. 简化性:重写和重载编写方式,前者,可以复用父类方法,简化子类的方法编写;后者就是一个方法名,装在不同的参数,进而不同的执行结果,不用编写多个方法名,也可以实现你想要的目的。

    多态存在的三个必要条件

    1、继承:在多态中必须存在有继承关系的子类和父类。
    2、重写:子类对父类中某些方法进行重新定义,在调用这些方法时就会调用子类的方法。
    3、向上(或下)转型:在多态中需要将子类的引用赋给父类对象,只有这样该引用才能够具备技能调用父类的方法和子类的方法。

    只有满足了上述三个条件,我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象,从而达到执行不同的行为。

    多态的实现方式

    1、重写或重载:

    重写:就是复用父类的同名方法,可以覆盖父类方法,也可以使用super 关键字启用父类方法
    重载:就是在复用父类的同名方法,但是原有方法无法达到需求,就对同名方法进行传参,来满足自己的需求,同时也可以使用super 关键字启用父类方法

    2、接口

    生活中的接口最具代表性的就是插座,有双口、有三口的

    3、抽象类和抽象方法

    实现的效果与接口差不多一样,都是不能实例化,只是一个工具类。主要的作用就是一次写好,下次继承立马就能全部导入,不用伤手指。

    展开全文
  • 多态通过分离做什么和怎么做,从另一个角度将接口和实现分离开来。多态不但能够改善代码的组织结构和可读性,还能创建可扩展的程序,无论在项目最初还是添加新功能的时候都是可“生长”的程序。简单的来说多态就是将...

    多态通过分离做什么和怎么做,从另一个角度将接口和实现分离开来。多态不但能够改善代码的组织结构和可读性,还能创建可扩展的程序,无论在项目最初还是添加新功能的时候都是可“生长”的程序。简单的来说多态就是将派生类的引用赋给基类,并通过基类的引用调用派生类的方法(前提派生类重写了基类的方法)。多态也称动作绑定,后期绑定或运行时绑定。对于不了解方法重写和向上转型的人们来说是很难理解多态的(下面将会介绍)。多态的作用是消除类型之间的耦合关系。

    方法重写(Override)和向上转型

    方法重写很容易理解,即两个方法的方法名、参数列表必须完全一致(一个方法在基类中,一个方法在父类中) ,派生类方法的返回类型必须是基类方法返回的类型,或是基类方法返回类型的派生类(协变返回类型)。例如:

    class Grain {//农作物

    public String toString() { return "Grain"; }//重写了object类的toString方法

    }

    class Wheat extends Grain {//小麦

    public String toString() { return "Wheat"; }

    }

    class Mill {//加工厂

    Grain process() { return new Grain(); }

    }

    class WheatMill extends Mill {//加工小麦

    Wheat process() { return new Wheat(); }//这里返回了基类返回类型的派生类(协变返回类型)

    }

    public class CovariantReturn {

    public static void main(String[] args) {

    Mill m = new Mill();

    Grain g = m.process();

    System.out.println(g);

    m = new WheatMill();

    g = m.process();

    System.out.println(g);

    }

    }

    对了这里要注意一点private,fianl和static方法不能被重写。

    对象既可以作为它自己本身的类型使用也可以作为它的基类类型使用。而这种把某个对象的引用视其为基类类型的引用称为向上转型。简单的说就是将派生类的对象引用赋给基类,可能我这么理解有些粗。在上一个例子中m = new WheatMill();就是向上转型。在看一个乐器类的例子:

    乐器要弹奏音符,所以我们单独创建一个乐符类Note。

    public enum Note {//乐符类

    MIDDLE_C, C_SHARP, B_FLAT; // Etc.

    }

    class Instrument {//基类

    public void play(Note n) {

    print("Instrument.play()");

    }

    }

    public class Wind extends Instrument {

    public void play(Note n) {

    System.out.println("Wind.play() " + n);

    }

    }

    public class Music {

    public static void tune(Instrument i) {

    i.play(Note.MIDDLE_C);

    }

    public static void main(String[] args) {

    Wind flute = new Wind();

    tune(flute); // 向上转型

    }

    }

    Mumsic.tune()方法接受一个Instrument引用,同事也接受Instrument子类的引用。在main()方法中,当向trune方法传递Wind引用时,就会出现向上转型,不需要任何类型转换,这是编译器帮我们完成的。 这样做是也许的,因为Wind继承自Instrument类,所以Instrument接口包含在Wind中。从Wind向上转型为instrument可能接口会"缩小",但是不会比instrument接口更窄。因为很有可能派生类不但重写了基类所有方法,而且还有自己的方法。这就要设计到继承的两种关系is-a和is-like-a,这里不说了。

    有些人可能会感到奇怪为什么不让tune方法直接接受Wind的引用作为自己的参数呢?这样会更为直接。假设按照这种推理,现在我们添加其他的的乐器类,比如添加Stringed(弦乐)和Brass(管乐):代码如下:

    class Stringed extends Instrument {

    public void play(Note n) {

    print("Stringed.play() " + n);

    }

    }

    class Brass extends Instrument {

    public void play(Note n) {

    print("Brass.play() " + n);

    }

    }

    public class Music2 {

    public static void tune(Wind i) {

    i.play(Note.MIDDLE_C);

    }

    public static void tune(Stringed i) {

    i.play(Note.MIDDLE_C);

    }

    public static void tune(Brass i) {

    i.play(Note.MIDDLE_C);

    }

    public static void main(String[] args) {

    Wind flute = new Wind();

    Stringed violin = new Stringed();

    Brass frenchHorn = new Brass();

    tune(flute); // No upcasting

    tune(violin);

    tune(frenchHorn);

    }

    }

    这样做也是行的通的,但是我要为每添加一种新的乐器添加一个对于的tune方法,如果要有上百种乐器,那你也添加上百个tune方法。显然这种写法比较垃圾,只有初学者才可能这样写。如果我们将接受参数为基类,而不是派生类。那么我们只需编写一个tune方法。将基类作为接口,直接与基类打交道。忽略派生类。这也正是多态所也许得。可以看到多态和继承之间的密切关系。

    有人可能会发现在上面的例子中tune方法接受一个Instrument引用,当我们传入Wind对象时,编译器怎么知道Instrument指向的是Wind对象,而不是Brass或String对象呢?这是因为java中方法绑定的机制,即将一个方法调用同一个方法体关联起来被称为绑定。若在程序执行之前进行绑定称为前期绑定。在程序运行时进行绑定称为后期绑定(运行时绑定,动态绑定),即多态。前面我们所疑惑的问题其实就是运用了后期绑定。这里知道就可以,具体怎么做的那是编译器的事。

    从下边的例子我们可以这样理解多态,Instrumen基类就像一个乐器团,这个乐器团中有很多乐器(像Stringed和Brass ),当对它们下达同一命令时(要调用哪个方法,比如演奏命令,这里就是调用paly()),它们就会按照自己的方式(play方法中的具体实现)去执行命令(调用play方法)。那我弦乐就是拉,管乐就是吹。

    在举个例子:就是你对同一支部队(同一个父类)的不同士兵(继承同一个父类的不同子类)下达同样的命令(调用命令对应的方法),他们会按自己的方式(方法具体实现)去执行命令(调用方法)。

    class Stringed extends Instrument {  public void play(Note n) {

    print("Stringed.play() " + n);

    }

    }

    class Brass extends Instrument {

    public void play(Note n) {

    print("Brass.play() " + n);

    }

    }

    public class Music2 {

    public static void tune(Instrument i) {

    i.play(Note.MIDDLE_C);

    }

    public static void main(String[] args) {

    Wind flute = new Wind();

    Stringed violin = new Stringed();

    Brass frenchHorn = new Brass();

    tune(flute); // No upcasting

    tune(violin);

    tune(frenchHorn);

    }

    }

    展开全文
  • Java|什么多态

    2021-03-05 23:50:23
    本篇文章将从贴近生活的案例,来解释什么多态多态(阅读以下内容,需要提前了解java继承和接口的知识)再结合案例前,得先知道多态的代码怎么写,以及一些相关规则.具有继承关系的父子类(或者是接口及其实现类),...
  • 什么多态 概念 一个类实例的相同方法在不同情形下有不同的表现形式。 多态机制使得具有不同内部结构的对象可以共享相同的外部接口。(利用多态可以得到良好的设计) 理解 谈到面向对象的编程语言时不...
  • 1. 通用多态 a.参数多态:模板。 b.包含多态:virtual。 2. 特定多态 a.重载多态: b.强制多态:强制类型转换。
  • 什么多态

    2020-10-23 23:31:27
    接口的多种不同的实现方式即为多态。 多态性是允许你将父对象设置成为一个或更多的他的子... 实际上多态包括动态多态(重写)和静态多态(重载)。 静态多态也称为编译时多态,即在编译时决定调用哪个方法; 静态多态一.
  • 学习java刚刚入门的小伙伴们,不知道大家在初次接触java中的多态一概念的时候,是否能清晰的讲出实现多态的机制是什么吗?什么才是java中的多态呢?多态性是指的面向对象程序设计代码重用的一个重要的机制,对于Java多...
  • 本篇博客让我们从一个完全不懂得状态一步步了解什么多态,深入掌握多态的概念。 什么多态? 让我们看看百度是怎么定义多态的,话不多说,上图! 望文生义,第一眼看到多态,感觉就是多种...
  • 参数多态包含多态、过载多态和强制多态

    万次阅读 多人点赞 2015-11-02 09:11:15
    多态分为两种:通用的多态和特定的多态。... 通用多态又分为参数多态(parametric)和包含多态(Inclusion Polymorphism);特定多态分为过载多态(overloading)和强制多态(coercion)。  强制多态
  • 一、认识多态1、方法调用在Java中,方法调用有两类,动态方法调用与静态方法调用。(1)静态方法调用是指对于类的静态方法的调用方式,是在编译时刻就已经确定好具体调用方法的情况,是静态绑定的。(2)动态方法调用...
  • 什么多态,重载算不算多态

    千次阅读 2018-10-05 21:27:39
    1,同一操作作用于不同的对象,...一种是编译时期多态又叫静态多态,编译时期的多态是靠重载实现的,根据参数个数,类型和顺序决定的(必须在同一个类中) 另一种是运行时的多态,在运行时根据实际情况决定调用函数...
  • 多态可以让我们不用关心某个对象到底是什么具体类型,就可以使用该对象的某些方法,从而实现更加 灵活的编程,提高系统的可扩展性。 允许不同类的对象对同一消息做出响应。即同一消息可以根据发
  • 静态多态包括了:函数重载,运算符重载,和重定义。 分别阐述一下: 函数重载首先在同一个作用域当中,函数的名字相同,但是函数的参数不同(类型,个数,顺序) void func(void) { cout<<"good! 没有参数"&...
  • 学习Java语言的过程中,对于多态的理解是非常关键的,理解了多态也就意味着打开了理解Java各种“抽象”的大门。所谓的“多态”,简单的理解就是对象在不同情况下的不同表现,具体体现在定义和功能两个方面,学习培训...
  • 接触Java这么久,我们一定都知道,作为面向对象阵营的典型代表,封装、继承、多态 (其实还应该包含抽象)是其三大基本特征 但是到底什么多态,它的底层又是如何实现的,又有什么优缺点,可能就没那么容易说清楚 ...
  • java多态是如何实现的?java的多态和c++一样,是通过延时绑定(late binding)或者说运行时绑定(runtime binding)来实现的。当调用某一个对象引用的方法时,因为编译器并不知道这个引用到底指向的是变量声明时说明的...
  • 4. 多态用虚函数来实现,结合动态绑定。5. 纯虚函数是虚函数再加上= 0。6. 抽象类是指包括至少一个纯虚函数的类。 纯虚函数:virtual void breathe()=0;即抽象类!必须在子类实现这个函数!即先有名称,没内容,在...
  • 多态性是面向对象程序设计代码重用的一个重要机制,我们曾不只一次的...“polymorphism(多态)”一词来自希腊语,意为“多种形式”。多数Java程序员把多态看作对象的一种能力,使其能调用正确的方法版本。尽管如此,...
  • 什么多态

    2020-06-30 15:29:37
    讲一讲什么多态: 1.多态的概念:同一个事物在不同场景下表现出不同的状态 举一个例子进行说明: 比如买票这个行为,当普通人买票时,是全价买票;学生买票时,是半价买票;军人买票时是优 先买票。 再举...
  • 多态

    2017-11-22 15:04:44
    我们通常使用抽象类来抽象要使用多态的方法: 特点: 1.必须要有继承关系,在抽象类中可以定义多态的抽象方法,通过子类来继承这个抽象类然后复写抽象类中的抽象方法以达到多态的效果。 2.多态子类的实例可以赋...
  • 一、前言 多态在面向对象中起着非常重要的作用。多态性的官方介绍是作用于不同的对象的同一操作可以有不同的解释,从而产生了不同的结果。翻译过来就是:用同一个方法对不同的人操作有不一样的结果。二、分类 多态...
  • 什么多态?如何实现?只看这一篇就够了

    万次阅读 多人点赞 2020-04-12 20:00:12
    1. 多态的概念 1.1 概念 多态的概念:通俗来说,就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态。 2. 多态的定义及实现 2.1多态的构成条件 多态是在不同继承关系的类对象,去调用...
  • java多态练习题

    2018-04-21 17:52:18
    java多态、继承练习题,包含题目与答案,............................................................................................................
  • 在面试过程中C++的多态实现机制经常会被面试官问道。大家清楚多态到底该如何实现吗?下面小编抽空给大家介绍下多态的实现...6. 抽象类是指包括至少一个纯虚函数的类。 多态的简单介绍 一般来说,多态分为两种,静态
  • 静态多态与动态多态

    2021-03-14 04:04:38
    面向对象编程的多态从绑定时间来看,可以分成静态多态和动态多态,也称为编译期多态和运行期多态。java中overload是静态多态,即根据参数列表进行最佳匹配,在编译阶段决定要具体执行哪个方法。而与之相反,overriden ...
  • 继承与多态.docx

    2020-06-22 09:54:39
    实验目的及要求 ...3) 理解什么多态 4) 掌握继承的设计技巧 实验内容 对某动物园的动物进行面向对象建模,需要利用面向对象中的继承和多态来设计类。 动物园包括的动物、动物类型以及他们的继承关系
  • 多态的实现主要分为静态多态和动态多态,静态多态主要是重载(函数重载,运算符重载),在编译的时候就已经确定;动态多态是用虚函数机制实现的,在运行期间动态绑定。举个例子:一个父类类型的指针指向一个 子类...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 179,541
精华内容 71,816
关键字:

多态包括什么