精华内容
下载资源
问答
  • 之前给大家介绍了一下什么是java多态,那么下面要给大家分享的就是一个重写怎样去实现多态性的实例。使用了类的继承和运行时多态机制。具体实现步骤:1、创建Figure类,在这个类当中,先要定义存储二维对象的尺寸,...

    之前给大家介绍了一下什么是java多态,那么下面要给大家分享的就是一个重写怎样去实现多态性的实例。

    使用了类的继承和运行时多态机制。

    具体实现步骤:

    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类的子类,所以的话,能够向上转型成这个类,从而实现多态。

    输出结果:长方形的面积:

    81.0

    ===

    === === === === === === === === === =

    三角形的面积:

    24.0

    ===

    === === === === === === === === === =

    父类中计算对象面积的方法, 没有实际意义, 需要在子类中重写。

    0.0

    更多java程序代码例子,请继续通过关注奇Q工具网来进行了解吧。

    推荐阅读:

    展开全文
  • 多态顾名思义,是多种状态,是指方法有多种不同的状态,在编译时或运行时才可以确定具体的状态,这种使程序具有多种状态的技术就叫做多态,在面向对象语言中,接口的多种不同的实现方式即为多态。

    1.多态

    多态顾名思义,是多种状态,是指方法有多种不同的状态,在编译时或运行时才可以确定具体的状态,这种使程序具有多种状态的技术就叫做多态,在面向对象语言中,接口的多种不同的实现方式即为多态。

    多态是同一个行为具有多个不同表现形式或形态的能力
    多态就是同一个接口,使用不同的实例而执行不同操作;

    2.编译期多态

    2.1重载

    重载,简单说,就是函数或者方法有相同的名称,但是参数列表不相同的情形,这样的同名不同参数的函数或者方法之间,互相称之为重载函数或者方法。

    编程中重载的定义:

    • 被重载的方法必须改变参数列表(参数个数或类型不一样);
    • 被重载的方法可以改变返回类型;
    • 被重载的方法可以改变访问修饰符;
    • 被重载的方法可以声明新的或更广的检查异常;
    • 方法能够在同一个类中或者在一个子类中被重载。
    • 无法以返回值类型作为重载函数的区分标准。

    2.2编译期

    编译期:是指把源码交给编译器编译成计算机可以执行的文件的过程。在Java中也就是把Java代码编成class文件的过程.编译期只是做了一些翻译功能,并没有把代码放在内存中运行起来,而只是把代码当成文本进行操作,比如检查错误。

    2.3总结

    重载是可以满足广义的多态的,同一个方法,在调用时可以有多种实现方式,重载在编译时就可以通过方法实参列表来确定方法的实现的状态。

    3.运行时多态

    3.1重写

    重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。

    • 参数列表与被重写方法的参数列表必须完全相同。

    • 返回类型与被重写方法的返回类型可以不相同,但是必须是父类返回值的派生类(java5 及更早版本返回类型要一样,java7 及更高版本可以不同)。

    • 访问权限不能比父类中被重写的方法的访问权限更低

    • 父类的成员方法只能被它的子类重写。

    • 声明为 final 的方法不能被重写。

    • 声明为 static 的方法不能被重写,但是能够被再次声明。

    • 子类和父类在同一个包中,那么子类可以重写父类所有方法,除了声明为 private 和 final 的方法。

    • 子类和父类不在同一个包中,那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。

    • 重写的方法能够抛出任何非强制异常,无论被重写的方法是否抛出异常。但是,重写的方法不能抛出新的强制性异常,或者比被重写方法声明的更广泛的强制性异常,反之则可以。

    • 构造方法不能被重写。

    • 如果不能继承一个类,则不能重写该类的方法。

    3.2运行时

    运行期:是把编译后的文件交给计算机执行,直到程序运行结束。所谓运行期就把在磁盘中的代码放到内存中执行起来,在Java中把磁盘中的代码放到内存中就是类加载过程,类加载是运行期的开始部分。

    3.3总结

    重写一定是有继承关系的,程序运行时,Java从实例所属的类(new 类)开始寻找匹配的方法执行,如果当前类中没有匹配的方法,则沿着继承关系逐层向上,依次在父类或各祖先类中寻找匹配方法,直到Object类。方法同样有两种状态,不过重载是水平的,重写是垂直的

    gitee

    展开全文
  • 多态性重写与重载

    2021-03-10 00:37:57
    问题就Java而言,当有人问:什么是多态?would重载or覆盖是可接受的答案?我认为还有更多的东西。...#1 热门回答(844 赞)表达多态性的最清晰方式是通过抽象基类(或接口)public abstract class Human{...public abs...

    问题

    就Java而言,当有人问:

    什么是多态?

    would重载or覆盖是可接受的答案?

    我认为还有更多的东西。

    如果你有一个抽象基类定义了一个没有实现的方法,并且你在子类中定义了该方法,那还是会覆盖吗?

    我认为6810153015重载**肯定不是正确答案。

    #1 热门回答(844 赞)

    表达多态性的最清晰方式是通过抽象基类(或接口)

    public abstract class Human{

    ...

    public abstract void goPee();

    }

    这个类是抽象的,因为goPee()方法不适用于人类。它只适用于男性和女性的子类。此外,人类是一个抽象的概念 - 你不能创造一个既不是男性也不是女性的人。它必须是一个或另一个。

    所以我们通过使用抽象类来推迟实现。

    public class Male extends Human{

    ...

    @Override

    public void goPee(){

    System.out.println("Stand Up");

    }

    }

    public class Female extends Human{

    ...

    @Override

    public void goPee(){

    System.out.println("Sit Down");

    }

    }

    现在我们可以告诉整个房间充满了人类去撒尿。

    public static void main(String[] args){

    ArrayList group = new ArrayList();

    group.add(new Male());

    group.add(new Female());

    // ... add more...

    // tell the class to take a pee break

    for (Human person : group) person.goPee();

    }

    运行这将产生:

    Stand Up

    Sit Down

    ...

    #2 热门回答(81 赞)

    Polymorphism是一个类实例的行为能力,就好像它是继承树中另一个类的一个实例,通常是它的祖先类之一。例如,在Java中,所有类都继承自Object。因此,你可以创建Object类型的变量,并为其分配任何类的实例。

    An覆盖是一种函数,它发生在继承自另一个类的类中。覆盖函数"替换"从基类继承的函数,但这样做的方式是,即使它的类的实例假装通过多态而成为不同的类型,也会调用它。参考前面的示例,你可以定义自己的类并覆盖toString()函数。因为此函数是从Object继承的,所以如果将此类的实例复制到Object类型变量中,它仍然可用。通常,如果在假装是Object时调用类上的toString(),实际触发的toString版本就是在Object本身上定义的版本。但是,因为函数是覆盖,所以即使类实例的真实类型隐藏在多态背后,也会使用类中toString()的定义。

    重载是使用相同名称但使用不同参数定义多个方法的操作。它与重写或多态无关。

    #3 热门回答(42 赞)

    这是伪C#/ Java中的多态性示例:

    class Animal

    {

    abstract string MakeNoise ();

    }

    class Cat : Animal {

    string MakeNoise () {

    return "Meow";

    }

    }

    class Dog : Animal {

    string MakeNoise () {

    return "Bark";

    }

    }

    Main () {

    Animal animal = Zoo.GetAnimal ();

    Console.WriteLine (animal.MakeNoise ());

    }

    Main函数不知道动物的类型,并且取决于MakeNoise()方法的特定实现的行为。

    编辑:看起来Brian打败了我。有趣的我们使用相同的例子。但上面的代码应该有助于澄清这些概念。

    展开全文
  • Java多态性理解

    2021-02-12 19:42:18
    什么是多态面向对象的三大特性:封装、继承、多态。...(发送消息就是函数调用)实现多态的技术称为:动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相...

    什么是多态

    面向对象的三大特性:封装、继承、多态。从一定角度来看,封装和继承几乎都是为多态而准备的。这是我们最后一个概念,也是最重要的知识点。

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

    实现多态的技术称为:动态绑定(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中多态的实现方式:接口实现,继承父类进行方法重写,同一个类中进行方法重载。

    一个小题目:继承父类进行方法重写的例子。

    (一)相关类

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    classA ...{

    publicString show(D obj)...{

    return ("A and D");

    }

    publicString show(A obj)...{

    return ("A and A");

    }

    }

    class B extendsA...{

    publicString show(B obj)...{

    return ("B and B");

    }

    publicString show(A obj)...{

    return ("B and A");

    }

    }

    class C extendsB...{}

    class D extends B...{}

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    (二)问题:以下输出结果是什么?

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    A a1 = newA();

    A a2 = newB();

    B b = newB();

    C c = newC();

    D d = newD();

    System.out.println(a1.show(b)); ① //a1指向的类时A

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

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

    System.out.println(a2.show(b)); ④ //a2指向的类时B,B类直接超类是A而且重写了show(A OBJ)。所以当传入的参数是B对象的时候,调用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)); ⑧ //b指向的类是B,而C,D类的直接超类是B所以调用的是show(B OBJ)。

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

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    (三)答案

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    ① 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

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    接口和抽象类的例子:

    对于抽象类和接口,有许多类实现这个接口(或者继承这个抽象类)。 在调用的时候,用父类引用指向子类对象的方法。然后,调用对象的方法,编译器就会自动根据这个对象实际属于哪个实现类, 来调出这个类对于接口或者抽象类的具体实现。

    例:

    public classAddress {privateString name;public Address(String name){ this.name =name; }public String getName() { returnname; }public void setName(String name) { this.name =name; }

    }

    定义基类(抽象类):

    public abstract classVehicle {abstract voidgo(Address address);

    }

    //Car对于基类的实现:public class Car extendsVehicle{

    @Overridepublic voidgo(Address address){

    System.out.println("Car to " +address.getName());

    }

    }

    Plane对于基类的实现:

    public class Plane extendsVehicle{

    @Overridevoidgo(Address address)

    { System.out.println("Plane to " +address.getName());

    }

    }

    Driver中多态:

    public voiddrive(Vehicle v){///多态,父类引用指向子类对象,实际传过来的是抽象类Vehicle的子类,或者实现类,然后编译器会根据具体实现类,来找实现方法。

    v.go(new Address("杭州(abstract)")); ///此方法在具体的实现中被重写

    }

    Test:public static voidmain(String[] args) {

    Driver d= newDriver();

    d.drive(new Plane()); //实际是Plane对象,则编译器就会找到Plane中,对go的实现 d.drive(new Car());//实际是Car对象,则编译器就会找到Plane中,对go的实现

    }

    输出结果: Plane to 杭州(abstract) Car to 杭州(abstract)

    事实上,这就是多态所起的作用,可以实现控制反转这在大量的J2EE轻量级框架中被用到,比如Spring的依赖注射机制。 (通过注入不同的bean,来得到不同的实现类)

    接口与抽象类的区别:

    有个概念,但还没有想到具体实现。 对于一些共用的,已经有实现了,可以设计成接口。

    上面是抽象类,下面把它转化为接口:

    IVehicle.java public interface IVehicle { public void go(Address address); }

    CarImpl.java public class CarImpl implements IVehicle{ public void go(Address address) { System.out.println("CarImpl to " +address.getName()); } }

    PlameImpl.java public class PlaneImpl implements IVehicle{ public void go(Address address) { System.out.println("PlaneImpl to " + address.getName()); } }

    Driver.java 多态之接口 public void driveI(IVehicle v){ v.go(new Address("杭州(interface)")); }

    Test.java 用接口实现 d.driveI(new PlaneImpl()); d.driveI(new PlaneImpl());

    打印结果: PlaneImpl to 杭州(interface) PlaneImpl to 杭州(interface)

    多态的三要素:1.继承  2.重写  3.父类引用指向子类对象

    以上就是我目前学习中的总结,如有不足之处,还望多多赐教。

    展开全文
  • ),在这个引用变量f指向的对象中,它的成员变量和静态方法与父类是一致的,他的非静态方法,在编译时是与父类一致的,运行时却与子类一致(发生了复写) 1. 什么是多态 多态是指允许不同子类型的对象对同一行为...
  • 看过一些关于Java多态性的文章,参考了很多人的理解,加入了一些自己的看法,整理出来供大家参考,不一定完全正确,欢迎大家批评指正。(一)相关类classA...{publicStringshow(Dobj)...{return("AandD");}...
  • 这篇文章主要介绍了Java中多态性实现方式,什么是多态?通过简单的一道题目帮大家理解java多态性,具有一定的参考价值,感兴趣的小伙伴们可以参考一下什么是多态面向对象的三大特性:封装、继承、多态。从一定角度...
  • 有了对象的多态性以后,我们在编译期只能调用父类中声明的额方法,在运行期,我们执行的是子类重写父类的方法 编译看左边,执行看右边 多态性的使用前提: 1、类的继承性 2、要有方法重写(不然没必要new子类对象...
  • Java 重载/重写/多态性

    2021-01-11 16:10:57
    重写主要用于子类和父类之间,在父类中定义了一个方法,同时在子类中对这个方法进行重写实现子类行为的特殊化,例如: class Animal { void eat() { System.out.print("animal eat"); } } class Tiger ...
  • java多态性多态分两种:(1) 编译多态(设计多态):方法重载。(2) 运行时多态:JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。(我们平时说得多的事运行时多态,所以多态...
  • Java中实现多态性方法有哪些发布时间:2020-12-05 16:13:13来源:亿速云阅读:53作者:Leah本篇文章为大家展示了Java中实现多态性方法有哪些,内容简明扼要并且容易理解,绝对能使你眼前一亮,通过这篇文章的...
  • Java的多态性方法重载方法覆盖方法重载Java 是支持重载的语言意味着同一个类中会出现两个或者两个以上同名的方法实现(在于两个函数间比较)参数个数不同参数类型不同参数名相同但类型不同计算图形面积的方法重载例子/...
  • Java中多态性实现什么是多态面向对象的三大特性:封装、继承、多态。从一定角度来看,封装和继承几乎都是为多态而准备的。这是我们最后一个概念,也是最重要的知识点。多态的定义:指允许不同类的对象对同一消息...
  • 展开全部在面向对象的程序JAVA中,多态性的定义是:同一操作作用于不同的32313133353236313431303231363533e78988e69d...多态性就是多种表现形式,即用"一个对外接口,多个内在实现方法"表示。多态性包...
  • java方法多态性理解

    2021-02-12 09:33:35
    1.什么是java的多态浏览了别人博客中的一些介绍多态的文章,发现大家的描述有点不一样,主要区别在于...(我们平时说得的事运行时多态,所以多态主要也是指运行时多态);上述描述认为重载也是多态的一种表现,不...
  • 方法的重载和重写都是实现多态的方式,区别在于前者实现的是编译多态性,而后者实现的是运行时多态性。重载发生在一个类中,同名的方法如果有不同的参数列表(参数类型不同、参数个数不同或者二者都不同)则...
  • Java多态性举例说明

    2021-02-26 15:10:00
    Java多态性的概念也可以被说成“一个接口,多个方法”。(一)相关类classA...{publicStringshow(Dobj)...{return("AandD");}publicStringshow(Aobj)...{return("AandA");}}classBextendsA...{publicStringshow(Bobj)....
  • 对外界而已它的内部细节是隐藏的,暴露给外界的只是它的访问方法。继承是为了重用父类代码。两个类若存在IS-A的关系就可以使用继承。,同时继承也为实现多态做了铺垫。那么什么是多态呢?多态的实现机制又是什么?请...
  • 方法重写(override/overwrite)定义:在子类中可以根据需要对从父类中继承来的方法进行改造,也称 为方法的重置、覆盖。在程序执行,子类的方法将覆盖父类的方法要求:1. 子类重写方法必须和父类被重写方法...
  • java中多态性的讲解

    2021-02-26 15:00:40
    多态具体表现在重写和重载多态就是类的多种表现方式比如方法的同名不同参子类重写父类方法重写和重载是Java多态性的不同表现。重写是父类与子类之间多态性的一种表现。重载是一个类中多态性的一种表现。如果在子类...
  • C++基础:什么是C++的多态性

    千次阅读 2020-12-28 18:50:10
    多态性可以简单地概括为“一个接口,多种方法”,程序在运行时才决定调用的函数,它是面向对象编程领域的核心概念。多态(polymorphisn),字面意思多种形状。 C++多态性是通过虚函数来实现的,虚函数允许子类重新定义...
  • 多态性面向对象(OOP)三大特性:封装、继承、多态。多态性(polymorphism)指同一行为具有多种不同表现形式,在面向对象程序设计中...面向对象多态性存在的三个必要条件继承重写父类引用指向子类对象多态性实现方式...
  • Java实现运行时多态性的基础是动态方法调度,它是一种在运行时而不是在编译期调用重载方法的机制。 方法重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现...
  • Java中多态性实现

    2021-02-12 18:34:19
    增加新的子类不影响已存在类的多态性、继承性,以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如,在实现了圆锥、半圆锥以及半球体的多态基础上,很容易增添球体类的多态性。 3.接口性(interface...
  • Java面向对象设计主要有三大特征:封装性、继承性和多态性一 封装性1.1 概念:它是将类的一些敏感信息隐藏在类的类部,不让外界直接访问到,但是可以通过getter/setter方法间接访问。1.2 目的:我们可以并且有可能在...
  • 【简答题】【选题】非经胃肠道给药的剂型是:【选题】除另有规定外,用药材比量法控制浸出制剂浓度的是:【判断题】【填空题】Java中规定,对于重写方法,Java根据调用该方法的 来决定选择哪个方法。 (4.0分)【简答...
  • 多态体现:方法的重载和重写对象的多态性2.对象的多态性:向上转型:程序会自动完成父类 父类对象 = 子类实例向下转型:强制类型转换子类 子类对象 = (子类)父类实例classA{publicvoidtell01(){System.out.println(...
  • Java面向对象之多态性

    2021-02-13 00:39:56
    一、多态性多态是指一个对象可以拥有多种不同的形态,继承是实现多态的基础。1.1 引用多态和方法多态引用多态:父类引用可以指向本类的对象,也可以指向子类的对象方法多态:1、创建本类对象,调用的方法为本类...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,397
精华内容 18,958
关键字:

方法的重写实现的是运行时的多态性