精华内容
下载资源
问答
  • 之前给大家介绍了一下什么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工具网来进行了解吧。

    推荐阅读:

    展开全文
  • 在继承层次结构中,父类和子类可能会定义同样的成员函数(方法)来实现同一种操作,但是由于父类比子类更抽象,所以两者的具体实现会不一样,运行时多态性能确保调用的是想要的那个方法。 这在JAVA中是通过“重写”...

    在继承层次结构中,父类和子类可能会定义同样的成员函数(方法)来实现同一种操作,但是由于父类比子类更抽象,所以两者的具体实现会不一样,运行时多态性能确保调用的是想要的那个方法。

    这在JAVA中是通过“重写”机制实现的:

            父类和子类具有相同的方法,其返回值、参数类型、方法名都相同,但具体实现不同。当一个父类引用绑定子类的对象时,该方法的调用是调用所绑定的子类对象中所定义的具体实现。

     

    在C++中,没有JAVA的这种“重写”机制,要实现相同的功能需要通过虚函数:

            如果基类和派生类定义了相同的函数,但是具有不同的实现,这时,用基类指针指向派生类对象,在通过这个基类指针调用前述的成员函数时,我们希望能够通过基类指针调用派生类中的实现,但是实际上它调用的是基类的函数实现,如果想基类指针调用的是它指向的派生类的实现,就要在基类的该同名函数前加virtual关键字,这时此函数就是虚函数。

            而且虚函数只对基类指针和基类引用有效,对基类对象无效,就是说如果把派生类对象赋值给基类对象那么该基类对象调用的还是基类中的函数。声明一个函数为虚函数时,会在类结构里加上一个指针,称为虚指针,它指向一个虚函数表。

            只要某个类的成员函数前加了virtual关键字,那么派生类的同名函数(要求返回类型同、形参列表同、名字相同)也默认是虚函数,即使没有加virtual。

    当然,如果只需要在子类对象调用父类中的某一方法时实现不同的操作,那么不需要用虚函数,直接在子类中重新定义该方法即可。这种情况称为编译时多态。

     

     

            定义矩形类Rectangle,具有长、宽两个属性,double area();计算面积。然后定义一个立方体类Cuboid,继承了矩形类,还增加了高度这个属性,double area();返回的是立方体表面积。分别用C++和JAVA测试

    (1)JAVA实现

     

    public class Rectangle {
    	protected int width,length;
    	public Rectangle(int width,int length){
    		this.width=width;
    		this.length=length;
    	}
    	public double area(){//获取矩形面积
    		int s=width*length;
    		System.out.println("矩形面积为"+s);
    		return s;
    	}
    }
    public class Cuboid extends Rectangle{
    	private int height;
    	public Cuboid(int width, int length, int height) {
    		super(width, length);
    		// TODO Auto-generated constructor stub
    		this.height=height;
    	}
    	public double area(){
    		int s=2*(width*height+length*height+width*length);
    		System.out.println("立方体表面积为"+s);
    		return s;
    	}
    }
    public class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Rectangle r1=new Rectangle(3,2);
    		Rectangle c1=new Cuboid(3,2,5);
    		r1.area();
    		c1.area();
    
    	}
    
    }

     

     

    程序运行结果:

    矩形面积为6
    立方体表面积为62

     

    (2)C++实现

     

    #include<iostream>
    using namespace std;
    //基类,矩形类
    class Rectangle{
    	protected:
    		int width,length;
    	public:
    		Rectangle(int width,int length){
    			this->width=width;
    			this->length=length;
    		}
    		virtual double area();//获取矩形面积,声明其为虚函数
    };
    double Rectangle::area(){
    		int s=width*length;
    		cout<<"矩形面积为"<<s<<'\n';
    		return s;
    }
    //派生自Rectangle的立方体类,和Rectangle有同样的area()成员函数
    class Cuboid :public Rectangle{
    	protected:
    		int height;
    	public:
    		Cuboid(int width, int length, int height):Rectangle(width,length){
    			this->height=height;
    		}
    		double area();
    };
    double Cuboid::area(){
    	int s=2*(width*height+length*height+width*length);
    	cout<<"立方体表面积为"<<s<<'\n';
    	return s;
    }
    int main(){
    	Rectangle r1(3,2),c0=Cuboid(3,2,5),*c;
    	Cuboid c1(3,2,5);
    	c=new Cuboid(3,2,5);
    	Rectangle& cc=c1;
    	
    	r1.area();//r1:  Rectangle对象
    	c0.area();//c0:  用Cuboid对象初始化的Rectangle对象
    	c->area(); //c :  指向Cuboid的Rectangle指针
    	cc.area();//cc:  基类引用
    	delete c;
    	c=NULL;
    }


    程序运行结果:

     

    矩形面积为6

    矩形面积为6

    立方体面积为62

    立方体面积为62
     

    展开全文
  • 继承和方法重写如何支持多态性

    千次阅读 2008-10-20 16:18:00
    Java实现运行时多态性的基础动态方法调度,它一种在运行时而不是在编译期调用重载方法的机制,下面就继承和接口实现两方面谈谈java运行时多态性实现。 一、通过继承中超类对象引用变量引用子类对象来实现 举例...

    运行时多态性是面向对象程序设计代码重用的一个最强大机制,动态性的概念也可以被说成“一个接口,多个方法”。Java实现运行时多态性的基础是动态方法调度,它是一种在运行时而不是在编译期调用重载方法的机制,下面就继承和接口实现两方面谈谈java运行时多态性的实现。

      一、通过继承中超类对象引用变量引用子类对象来实现

      举例说明:

      //定义超类superA
      class superA
      {
      int i = 100;
      void fun()
      {
      System.out.println(“This is superA”);
      }
      }
      //定义superA的子类subB
      class subB extends superA
      {
      int m = 1;
      void fun()
      {
      System.out.println(“This is subB”);
      }
      }
      //定义superA的子类subC
      class subC extends superA
      {
      int n = 1;
      void fun()
      {
      System.out.println(“This is subC”);
      }
      }

      class Test
      {
      public static void main(String[] args)
      {
      superA a;
      subB b = new subB();
      subC c = new subC();
      a=b;
      a.fun(); (1)
      a=c;
      a.fun(); (2)
      }
      }

      运行结果为:

      This is subB
      This is subC

      上述代码中subB和subC是超类superA的子类,我们在类Test中声明了3个引用变量a, b, c,通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。也许有人会问:“为什么(1)和(2)不输出:This is superA”。java 的这种机制遵循一个原则:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。

      所以,不要被上例中(1)和(2)所迷惑,虽然写成a.fun(),但是由于(1)中的a被b赋值,指向了子类subB的一个实例,因而(1)所调用的fun()实际上是子类subB的成员方法fun(),它覆盖了超类superA的成员方法fun();同样(2)调用的是子类subC的成员方法fun()。

      另外,如果子类继承的超类是一个抽象类,虽然抽象类不能通过new操作符实例化,但是可以创建抽象类的对象引用指向子类对象,以实现运行时多态性。具体的实现方法同上例。

      不过,抽象类的子类必须覆盖实现超类中的所有的抽象方法,否则子类必须被abstract修饰符修饰,当然也就不能被实例化了。
                                                                            通过方法重写实现多态

    一.多态性(如果您不是搞软件的下边有其他更精彩的内容)

      在java语言中,多态性体现在两个方面:由方法重载实现的静态多态性(编译时多态)和方法重写实现的动态多态性(运行时多态)。
      1) 编译时多态
      在编译阶段,具体调用哪个被重载的方法,编译器会根据参数的不同来静态确定调用相应的方法。
      2) 运行时多态
      由于子类继承了父类所有的属性(私有的除外),所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方,都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。
      ◇ 重写方法的调用原则(读者朋友请注意此处为重点):java运行时系统根据调用该方法的实例,来决定调用哪个方法。对子类的一个实例,如果子类重写了父类的方法,则运行时系统调用子类的方法;如果子类继承了父类的方法(未重写),则运行时系统调用父类的方法。

    一.对象的类型转换
    1、子类转换成父类(经典例题)
    class A {
         public void func1() {
              System.out.println("A func1 is calling.");
         }
         public void func2() {
              func1();
         }
    }
    class B extend A {
         public void func1() {
              System.out.println("B func1 is calling.");         
         }
         public void func3() {
              System.out.println("B func3 is calling.");
         }
    }
    class C {
         public static void main(String[] args) {
              B b = new B();
              A a = b;
              callA(a);
              callA(new B());
         }
         public void callA(A a) {
       
    展开全文
  • 这些方法的目的也许一样的,但是它们的实现方式会根据传入的参数不同而不同。重写涉及到继承这个概念中的问题。子类继承了父类的方法,但是它可能需要有不同的操作行为,这时候就需要在子类中重写这个父类方法。...

    重载和重写除了在名称上有些相似之外,其实是完全不同的两个东西。

    重载的目的是使得我们能够用用一个统一的接口名称来调用一系列方法。这些方法的目的也许是一样的,但是它们的实现方式会根据传入的参数不同而不同。

    重写涉及到继承这个概念中的问题。子类继承了父类的方法,但是它可能需要有不同的操作行为,这时候就需要在子类中重写这个父类方法。

    重载本身并不是多态,同时运行时绑定重载方法也不是多态的表现。它们以及一些其他的东西都是其面向对象多态性的使用(原文:All these and more are used to exercise the object oriented property polymorphism.总感觉翻译不要,故贴上来)。

    重载和重写的关键点

    • private: 一个私有的java方法是不能被重写的,因为它对子类压根就不可见
    • final:重载一个final的方法是可以的,但是不能重写它,因此父类如果将方法声明为final的就可保证所有子类的调用此方法时调用的都是父类的方法。
    • final:如果两个方法有同样的参数列表,而其中一个的参数被声明为final的这种情况下这两个方法完全一样,因此不可重载。编译都通不过,因为这两个方法被视为完全一样。
    • static:可以重载一个静态的Java方法但是不能重写静态的Java方法,因为静态方法在方法区中只有一个。
    • static:重载是关于对象(实例)和继承而言的。一个声明为静态的方法属于整个类(对于这个的所有对象都是一样的)。因此重写它没有任何意义。
    • static:对于重载,两个静态方法的重载没有什么特别的,只不过是修饰符多了个static修饰符。参数列表依然必须不同。
    • 重载

    让我们来详细讨论下重载。在各种网站上我看到了大量的重载的例子。它们向类中添加更多的属性、方法,把它变得看起来更庞大作为重载的象征。事实上正确的方式是,当我们使用重载时外部看起来我们的类会变得更加紧凑。

    Java Example for Method Overloading

    6d8b620c65d49619a98514698fe15326.png

    Java Overloading Puzzle

    package com.javapapaer.java;

    1bc9f63bd56933df0f1f5b723e88dd14.png

    猜一猜,上面的输出是啥?

    Overriding 重写

    当继承一个类的时候,根据父类方法的访问修饰符子类可以获得所有protect以上的父类方法。但是父类的方法的具体行为可能在子类中并不适合,因此我们需要根据子类对于这个方法的需求重写继承自父类的这个方法。重写后原来的旧方法对于这个子类会完全废弃。

    Overriding in Java/JDK

    在Java中默认所有对象都是继承自Object类。Object有个叫equals的方法,在String类中重写了它的默认行为。String中通过比较传入的对象与本身保存的字符串序列一一对比看是否相等。

    #分割线~~~~~~~~~~~~~~~~~~~~~~~

    关于上面Overloading Puzzle,以免强迫症患者费心敲代码在此给出答案和解释。

    程序输出:Double array argument method.

    原因是Java对于重载的处理有个最精确原则。Object和double[]都可以和null匹配,但是两者对比而言,double[]比Object匹配得更精确,所以调用了下面的overLoad方法。如果想让程序调用Object的overLoad方法则需要一个强制类型转换obj.overLoad((Object)null);这样Object的overLoad就要比double[]的更精确,会输出Object o arguement method.

    下面这段代码也许理解起来会更清晰一些,ArrayList继承自List:

    fe6d57b2595e44e8ec78084a536a1154.png

    那么它将输出:ArrayList arguement method,因为ArrayList比List匹配得更精确。

    那又要问了,如果上文的NullArguementOverloading代码中还有个overLoad方法如下:

    41af5a8236138d18ce240ba89a171fde.png

    那么程序会怎样呢?答案是main函数obj.overLoad(null)那一行会编译报错。String的overLoad和double[]的overLoad都可以匹配,但是两者在继承属上是平行的,因此编译器也不知道到底该调用哪一个重载方法。另外这段代码还说明了一个问题:重载是在编译期就已经确定了的,并不需要等到运行时才能确定。这也是为什么说它不是多态的一个原因。

    还有下面一段代码作为佐证:

    7d8c537a5ecb4b9e9b62610b20725f2b.png

    程序输出:List arguement method.。显然这里重载对于传入的参数类型只认了引用的类型,并没有去解析实际对象的类型。如果重载是一种多态的话,它这里应该去解析实际对象的类型并调用ArrayList的方法。

    2fcd10b00c9f6e02f01d68814c0b1682.png
    展开全文
  • 这些方法的目的也许一样的,但是它们的实现方式会根据传入的参数不同而不同。 重写涉及到继承这个概念中的问题。子类继承了父类的方法,但是它可能需要有不同的操作行为,这时候就需要在子类中重写这个父类...
  • java中的方法重载和方法重写有很多区别。 下面给出了方法重载和方法覆盖之间差异列表:编号方法重载方法重写1方法重载用于提高程序可读性。方法重写用于提供已经由其超类...方法重写/覆盖是运行时多态性的例子。...
  • 方法重载是实现的是编译时的多态性(也称前绑定),方法重写实现的是运行时的多态性(也称后绑定)。 一、方法重写(0veriding) 在Java程序中,类的继承关系可以产生一个子类,子类继承父类,它具备了父类所有的特征...
  • 这些方法的目的也许一样的,但是它们的实现方式会根据传入的参数不同而不同。 重写涉及到继承这个概念中的问题。子类继承了父类的方法,但是它可能需要有不同的操作行为,这时候就需要在子类中重写这个父类方法。...
  • Java (多态性)(重写

    千次阅读 2016-08-30 00:58:27
    编译多态指在程序编译过程中体现出的多态性,如方法重载,尽管方法名相同,但由于参数不同,在调用系统根据传递参数的不同确定被调用的方法,这个过程在编译完成的,例如定义一个作图的类,它有一个draw()...
  • 多态性可以简单地概括为“一个接口,多种方法”,程序在运行时才决定调用的函数,它面向对象编程领域的核心概念。多态(polymorphisn),字面意思多种形状。 C++多态性是通过虚函数来实现的,虚函数允许子类重新定义...
  • 深入理解C++的多态性

    2020-12-31 11:28:32
    多态性可以简单地概括为“一个接口,多种方法”,程序在运行时才决定调用的函数,它面向对象编程领域的核心概念。多态(polymorphisn),字面意思多种形状。C++多态性是通过虚函数来实现的,虚函数允许子类重新定义...
  • Java多态性的表现

    千次阅读 2014-12-01 22:51:31
    Java实现运行时多态性的基础动态方法调度,它一种在运行时而不是在编译期调用重载方法的机制。 方法的重写(Overriding)和重载(Overloading)Java多态性的不同表现。 重写父类与子类之间多态性的一种表现,...
  • Java方法的重载与重写

    2020-11-27 20:22:00
    重载和重写是多态的体现 Java 三大特性: 封装、...方法的重载和重写多态性的体现, 区别重载实现编译时的多态性, 后者实现运行时的多态性 重载发生在一个类中, 重写发生在子类与父类之间 重载方法必须至少有形
  • java 多态性的理解

    2011-09-05 10:03:44
    运行时多态性是面向对象程序设计代码重用的一个最强大机制,Java...Java实现运行时多态性的基础动态方法调度,它一种在运行时而不是在编译期调用重载方法的机制。 方法的重写Overriding和重载OverloadingJava
  • C# 多态性的深入理解

    2021-01-20 06:37:18
    2.基类定义实现方法,派生类重写这些方法,在运行时,CLR会查找运行时类型,并且调用派生类重写的方法. 代码如下: class Shape { public virtual void Draw() { Console.WriteLine(“Draw a s
  • 动态多态指在运行中才能动态的确定方法所指对象,动态多态的实现方式是重写父类中同名成员方法,其调用规则依据对象在实例化时而非定义时的类型,相应的调用对应类中的同名成员方法,它需要通过动态绑定和重写机制...
  • [java面试]关于多态性的理解

    千次阅读 2015-07-02 14:28:49
    运行时多态性是面向对象程序设计代码重用的一个最强大...方法的重写Overriding和重载OverloadingJava多态性的不同表现。重写Overriding父类与子类之间多态性的一种表现,重载Overloading一个类中多态性的一种表
  • C++中的多态性

    2017-02-28 09:33:01
     C++多态性是通过虚函数来实现的,虚函数允许子类重新定义成员函数,而子类重新定义父类的做法称为覆盖(override),或者称为重写重写的话可以有两种,直接重写成员函数和重写虚函数,只有重写了虚函数的才能算作...
  • 1、方法的重载和重写都是实现多态的方式,区别在于前者实现的是编译时的多态性,而后者实现的是运行时的多态性。重载发生在一个类中,同名的方法如果有不同的参数列表(参数类型不同、参数个数不同或者两者都不同)则...
  • Java 多态性

    2018-02-08 19:52:17
    其中编辑时多态静态的,主要方法的重载,它根据参数列表的不同来区分不同的函数,通过编辑之后会变成两个不同的函数,在运行时谈不上多态。而运行时多态动态的,它通过绑定来实现的,也就是多态。 多态...
  • 的多态性

    2019-09-21 21:36:14
    //多态就是指在程序运行时,执行的虽然一个调用方法的语句,却可以根据派生类对象的类型的不同完成方法不同的具体实现  //当派生类从基类继承时,它会获得积累的所有方法,字段,属性,和事件.派生类可以选择: //1....
  • 多态性

    2019-10-08 07:23:08
    ①②③比较好理解,一般不会出错。④⑤就有点糊涂了,为什么输出的...Java实现运行时多态性的基础动态方法调度,它一种在运行时而不是在编译期调用重载方法的机制。 方法的重写Overriding和重载OverloadingJ...
  • 方法的重载和重写都是实现多态的方式,区别在于前者实现的是编译时的多态性,而后者实现的是运行时的多态性。 重载发生在一个类中,同名的方法如果有不同的参数列表(参数类型不同、参数个数不同或者二者都不同)则...
  • 方法重载方法重写 方法重载用于提高程序的可读性 方法重写用于提供已经由其超类提供的方法的特定实现 ...方法重写/覆盖是运行时多态性的例子 返回类型任意 子类的方法返回的权限修饰...
  • Java多态性

    2018-06-08 22:34:29
    运行时多态性是面向对象程序设计代码重用的一个最强大机制,Java多态性的概念也... 方法的重写Overriding和重载OverloadingJava多态性的不同表现。重写Overriding父类与子类之间多态性的一种表现,重载Overloa...
  • 重载和重写的实现原理

    千次阅读 2018-08-28 20:08:46
    多态性特征最基本体现有“重载”和“重写”,其实这两个体现在Java虚拟机中分派作用。 分派又分为静态分派和动态分派,静态分派指所有依赖静态类型来定位方法执行版本分派动作,动态分派指在运行期根据...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 331
精华内容 132
关键字:

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