精华内容
下载资源
问答
  • 多态 重载

    2015-09-06 22:07:35
    重载 多个方法拥有相同的名字 但必须有不同的参数(个数 类型) 1普通方法的重载 2构造方法的重载

    重载 多个方法拥有相同的名字 但必须有不同的参数(个数 类型)

    1普通方法的重载

    2构造方法的重载


    展开全文
  • java 多态重载 PPT

    2010-12-07 14:45:28
    这个PPT详细展示了java的多态重载和重写,展示了重载和覆盖的不同点及区别办法
  • 《Head First Java》Day3接口与多态重载构造函数Static & Final 接口与多态 重载构造函数 Static & Final 每日一乐

    接口与多态

    在这里插入图片描述
    在这里插入图片描述

    重载构造函数

    在这里插入图片描述

    在这里插入图片描述

    Static & Final

    在这里插入图片描述


     每日一乐
    

    在这里插入图片描述

    展开全文
  • 多态重载重写

    2015-08-30 12:28:26
    在面向对象的世界里,多态重载是初学者最难理解的问题之一,也是最容易混淆的两个概念。  一、多态  面向对象的设计原则中有一条里氏代换原则:父类出现的地方,子类一定可以出现,反之则不一定;多态即是这一...

     在面向对象的世界里,多态与重载是初学者最难理解的问题之一,也是最容易混淆的两个概念。

        一、多态

        面向对象的设计原则中有一条里氏代换原则:父类出现的地方,子类一定可以出现,反之则不一定;多态即是这一原则的具体表现形式,设有父类为A,含有方法g(),B1B2……BnA类的子类,每个子类都以自己的方式实现了方法g(),当类A的对象向子类对象发出消息g()时,接收到此消息的各B子类对象将表现出不同的行为,这种现象即为多态。

    如下代码所示:

    class A { public void g()}

    class B extends A { public void g() { System.out.println("This is B")}}

    class C {

         public static void main(String[] args)

         { 

         A a=new B();//其中A为父类,B为子类,对象a的数据类型为A,而其实体类型为B

          a.g();

          }

    }

        再比如:

     class Graph

       {

          public void draw();

        }

     class Rect extends Graph

        {

          public void draw()

            {

              System.out.println("draw rectangle");

            }

          }

    class Circle extends Graph

         {

            public void draw()

             {

                System.out.println("draw circle");

              }

          }

    class UserGraph

        {

         public static void main(String[] args)

          {     

           Graph a=new Rect();

           Graph b=new Circle();

           a.draw();b.draw()

          }

         }

        二、重载

        重载分为构造方法重载和方法重载,重载即指在同一类内,两个以上的构造方法或同名方法,使用不同类型或不同个数的参数的现象就称为重载,如为了实现加法运算,我们可以定义同名的方法add,但根据运算的对象不同,参数分别为整数、实数等等)

        方法重载

        class adder{

        int add(int i,int j){return i+j;}

        double add(double i,double j){return i+j;}

        构造方法重载

        class adder{

         int n;

         double x;

         adder(int i, int j){n=i+j;}

         adder(double i,double j){x=i+j;}

     




     

     多态性,这个面向对象编程领域的核心概念,本身的内容博大精深,要以一文说清楚实在是不太可能。加之作者本人也还在不断学习中,水平有限。因此本文只能描一下多态的轮廓,使读者能够了解个大概。如果有描的不准的地方,欢迎指出,或与作者探讨(作者Emailnicrosoft@sunistudio.com

    首先,什么是多态(Polymorphisn)?按字面的意思就是多种形状。我手头的书上没有找到一个多态的理论性的概念的描述。暂且引用一下Charlie Calverts的对多态的描述吧——多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作(摘自“Delphi4 编程技术内幕)。简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针。多态性在Object PascalC++中都是通过虚函数(Virtual Function
    实现的。

    好,接着是虚函数(或者是虚方法)。虚函数就是允许被其子类重新定义的成员函数。而子类重新定义父类虚函数的做法,称为覆盖override),或者称为重写

    这里有一个初学者经常混淆的概念。覆盖(override)和重载(overload)。上面说了,覆盖是指子类重新定义父类的虚函数的做法。而重载,是指允许存在多个同名函数,而这些函数的参数表不同(或许参数个数不同,或许参数类型不同,或许两者都不同)。其实,重载的概念并不属于面向对象编程,重载的实现是:编译器根据函数不同的参数表,对同名函数的名称做修饰,然后这些同名函数就成了不同的函数(至少对于编译器来说是这样的)。如,有两个同名函数:function func(p:integer):integer;function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的:int_funcstr_func。对于这两个函数的调用,在编译器间就已经确定了,是静态的(记住:是静态)。也就是说,它们的地址在编译期就绑定了(早绑定),因此,重载和多态无关!真正和多态相关的是覆盖。当子类重新定义了父类的虚函数后,父类指针根据赋给它的不同的子类指针,动态(记住:是动态!)的调用属于子类的该函数,这样的函数调用在编译期间是无法确定的(调用的子类的虚函数的地址无法给出)。
    因此,这样的函数地址是在运行期绑定的(晚邦定)。结论就是:重载只是一种语言特性,与多态无关,与面向对象也无关!

    引用一句Bruce Eckel的话:不要犯傻,如果它不是晚邦定,它就不是多态。

    那么,多态的作用是什么呢?我们知道,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用!而且现实往往是,要有效重用代码很难,而真正最具有价值的重用是接口重用,因为接口是公司最有价值的资源。设计接口比用一堆类来实现这个接口更费时间。而且接口需要耗费更昂贵的人力的时间。

    其实,继承的为重用代码而存在的理由已经越来越薄弱,因为组合可以很好的取代继承的扩展现有代码的功能,而且组合的表现更好(至少可以防止类爆炸)。因此笔者个人认为,继承的存在很大程度上是作为多态的基础而非扩展现有代码的方式了。

       
    什么是接口重用?我们举一个简单的例子,假设我们有一个描述飞机的基类(Object Pascal语言描述,下同):

    type
    plane = class
    public
    procedure fly(); virtual; abstract; //起飞纯虚函数
    procedure land(); virtual; abstract; //着陆纯虚函数
    function modal() : string; virtual; abstract; //查寻型号纯虚函数
    end;

    然后,我们从plane派生出两个子类,直升机(copter)和喷气式飞机(jet):
    copter = class(plane)
    private
    fModal : String;
    public
    constructor Create();
    destructor Destroy(); override;
    procedure fly(); override;
    procedure land(); override;
    function modal() : string; override;
    end;

    jet = class(plane)
    private
    fModal : String;
    public
    constructor Create();
    destructor Destroy(); override;
    procedure fly(); override;
    procedure land(); override;
    function modal() : string; override;
    end;

    现在,我们要完成一个飞机控制系统,有一个全局的函数
    plane_fly,它负责让传递给它的飞机起飞,那么,只需要这样:

    procedure plane_fly(const pplane : plane);
    begin
    pplane.fly();
    end;

    就可以让所有传给它的飞机(
    plane的子类对象)正常起飞!不管是直升机还是喷气机,甚至是现在还不存在的,以后会增加的飞碟。因为,每个子类都已经定义了自己的起飞方式。

    可以看到
    plane_fly函数接受参数的是 plane类对象引用,而实际传递给它的都是 plane的子类对象,现在回想一下开头所描述的多态:多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。

    很显然,
    parent = child; 就是多态的实质!因为直升机是一种飞机,喷气机也是一种飞机,因此,所有对飞机的操作,都可以对它们操作,此时,飞机类就作为一种接口。

    多态的本质就是将子类类型的指针赋值给父类类型的指针(在
    OP中是引用),只要这样的赋值发生了,多态也就产生了,因为实行了向上映射

    应用多态的例子非常普遍,在
    DelphiVCL类库中,最典型的就是:TObject类有一个虚拟的Destroy虚构函数和一个非虚拟的Free函数。Free函数中是调用Destroy的。因此,当我们对任何对象(都是TObject的子类对象)调用 .Free();之后,都会执行 TObject.Free();,它会调用我们所使用的对象的析构函数 Destroy();。这就保证了任何类型的对象都可以正确地被析构。

    多态性作为面向对象最重要的特性,本文所提不过是沧海一粟,还有很多内容。如果可能,希望会有后文继续探讨多态。


    展开全文
  • 多态 重载 重写

    2015-12-30 10:44:00
    重写(覆盖)的规则: 1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载. 2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符(public>protected>default>private)...

    override是重写(覆盖)了一个方法,以实现不同的功能。一般是用于子类在继承父类时,重写(重新实现)父类中的方法。
    重写(覆盖)的规则:
    1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.
    2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符(public>protected>default>private)。
    3、重写的方法的返回值必须和被重写的方法的返回一致;
    4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致,或者是其子类;
    5、被重写的方法不能为private,否则在其子类中只是新定义了一个方法,并没有对其进行重写。
    6、静态方法不能被重写为非静态的方法(会编译出错)。

    overload是重载,一般是用于在一个类内实现若干重载的方法,这些方法的名称相同而参数形式不同。
    重载的规则:
    1、在使用重载时只能通过相同的方法名、不同的参数形式实现。不同的参数类型可以是不同的参数类型,不同的参数个数,不同的参数顺序(参数类型必须不一样);
    2、不能通过访问权限、返回类型、抛出的异常进行重载;
    3、方法的异常类型和数目不会对重载造成影响;

    多态的概念比较复杂,有多种意义的多态,一个有趣但不严谨的说法是:继承是子类使用父类的方法,而多态则是父类使用子类的方法。
    一般,我们使用多态是为了避免在父类里大量重载引起代码臃肿且难于维护。
    多态(Polymorphism)按字面的意思就是“多种状态”。在面向对象语言中,接口的多种不同的实现方式即为多态

    举个例子:

    public class Shape
    {
      public static void main(String[] args){
        Triangle tri = new Triangle();
        System.out.println("Triangle is a type of shape? " + tri.isShape());// 继承
        Shape shape = new Triangle();
        System.out.println("My shape has " + shape.getSides() + " sides."); // 多态
        Rectangle Rec = new Rectangle();
        Shape shape2 = Rec;
        System.out.println("My shape has " + shape2.getSides(Rec) + " sides."); //重载
      }
      public boolean isShape(){
        return true;
      }
      public int getSides(){
        return 0 ;
      }
      public int getSides(Triangle tri){ //重载
        return 3 ;
      }
      public int getSides(Rectangle rec){ //重载
        return 4 ;
      }
    }
    class Triangle extends Shape
    {
      public int getSides() { //重写,实现多态
        return 3;
      }
    }
    class Rectangle extends Shape
    {
      public int getSides(int i) { //重载
        return i;
      }
    }

    注意Triangle类的方法是重写,而Rectangle类的方法是重载。对两者比较,可以发现多态对重载的优点:
    如果用重载,则在父类里要对应每一个子类都重载一个取得边数的方法;
    如果用多态,则父类只提供取得边数的接口,至于取得哪个形状的边数,怎样取得,在子类里各自实现(重写)。

     

    总结:

     多态,就是多个子类对父类的方法重写,父类可以通过引用不同的子类实例,实现调用不同的子类实现,形成多种状态。

       重写,子类重新实现父类的方法。重写是实现多态的方式之一。

       重载,一个类中方法名相同,但是形参不同的情况称之为重载。

       多态和重写存在于父子类之间,而重载是在一个类中。

    转载于:https://www.cnblogs.com/wuMing-dj/p/5088051.html

    展开全文
  • C++中 多态 重载 覆盖

    千次阅读 2015-05-11 16:01:48
    多态是指两个或多个属于不同类的对象,对于同一个消息(方法调用)作出不同响应的方式。(同样的操作,不同的对象执行,就会出现不同的结果。) 、、、、、、、、、 实现多态的方式: 函数重载;运算符重载
  • 1. 通用多态 a.参数多态:模板。 b.包含多态:virtual。 2. 特定多态 a.重载多态: b.强制多态:强制类型转换。
  • 多态重载

    2021-06-13 11:04:16
    多态重载前言一、多态1. 定义格式2. 多态的特点3. 多态的示例二、重载1. 重载的作用2. 重载的原则3. 重载的示例2.读入数据总结 前言 提示:这里可以添加本文要记录的大概内容: 例如:随着人工智能的不断发展,...
  • 多态重载的区别及用法

    千次阅读 2020-07-21 08:57:23
    文章目录多态重载 多态 在同一个方法中,由于参数类型的不同从而导致执行效果各异的现象就是多态。 重载 java允许一个程序中定义多个名称相同的方法,但是参数类型或个数必须不同 方法的重载和返回值类型无关,他只...
  • 多态归结起来有四种:重载多态,强制多态,包含多态,参数多态。运算符重载实际上是函数重载。 上代码: 重载运算符 ++ 分为前置和后置,其中重载函数带参数的是后置。 #include <iostream> using ...
  • 多态重载

    2019-01-21 17:20:14
    1. 多态重载的区别 对于面向对象,多态分为编译时多态和运行时多态。其中编辑时多态是静态的,主要是指方法的重载,它是根据参数列表的不同来区分不同的函数,通过编辑之后会变成两个不同的函数,在运行时谈不上...
  • 面向对象之封装、继承、多态、重载总结封装继承多态重载 封装 类 数据成员 成员函数(构造,析构,工具,行为) 继承 派生类继承共享基类 派生类改写—重写(override)(析构和改写的函数virtual) 派生类添加新...
  • 多态 重写 重载

    2019-04-25 14:29:00
    多态(狭义上的):同一个方法对不同的对象调用行为不同的现象。 重写:同一方法在不同类中的重新实现。 重载:不同的方法。 多态包括 重写 重载 ...
  • 主要介绍了C#中多态重载、重写区别,采用实例较为通俗易懂的分析了多态重载的重写的概念与用法,对于C#初学者有非常不错的借鉴价值,需要的朋友可以参考下
  • 主要介绍了SQL封装、多态重载的相关资料,非常不错,具有参考借鉴价值,需要的朋友可以参考下
  • &...而网上所能查到的资料,大部分支持的观点是重载多态,没提到多态,就提到了override和overload区别,令人生疑。还有模糊地说法说的是重载算是广义的多态。 &amp;amp;nbsp;&amp;am
  • 重载多态

    2020-10-12 10:11:19
    重载多态 重载多态与重写的区别: 重载 : 函数名相同,但是函数的参数不同,调用时根据参数的不同决定调用哪一个函数。 多态 : 函数名相同,函数形参相同。调用时根据函数类型时虚函数还是普通函数决定调用哪...
  • 多态重载的区别

    千次阅读 2018-01-01 15:44:40
    多态重载  说到这两个名词想必有许多人还没有区分吧,在网上也看到许多资料感觉写的都挺多的,最后自己理解了以后感觉其实并不难分别,下面我就说说我个人的看法。  多态多态是对于类来说的,同一个类根据...
  • 关于Java多态重载

    2020-10-18 22:14:49
    关于多态重载 多态 什么是多态 多态是同一个行为具有多个不同表现形式或形态的能力。 多态存在三个条件 继承 重写 父类引用指向子类对象 体现 父类类型的引用 指向 子类的对象 Person p = new Teacher(); 该...
  • 主要介绍了Java中继承、多态重载和重写介绍,需要的朋友可以参考下
  • 区别多态重载

    2017-07-06 19:44:55
    多态重载的区别 重载可认为是静态的多态,静态联编,发生在编译阶段; 多态是动态的,动态联编,发生在运行阶段; 静态的比动态的效率高,但动态的最大优点是多态性,提高代码复用性。 (1)实现...
  • 什么叫多态重载算不算多态

    千次阅读 2018-10-05 21:27:39
    1,同一操作作用于不同的对象,...一种是编译时期多态又叫静态多态,编译时期的多态是靠重载实现的,根据参数个数,类型和顺序决定的(必须在同一个类中) 另一种是运行时的多态,在运行时根据实际情况决定调用函数...
  • 继承与多态重载的区别,java实现
  • C++---多态重载多态

    2019-04-23 21:18:34
    函数重载指有多个同名函数,对名称进行了重载。 函数的参数列表,也称为函数特征标。两函数的参数的数目、类型、参数的排列顺序相同,则函数的特征标相同。C++中可以定义名称相同的函数,但它们的特征标不能相同。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 104,248
精华内容 41,699
关键字:

多态重载