精华内容
下载资源
问答
  • 多态性(一)——静态多态性

    千次阅读 2015-03-04 12:18:55
    在C++中,多态性表现形式之一是:具有不同功能的函数可以用同一个函数名,这样就可以实现用一个函数名调用不同内容的函数。  从系统实现的角度来看,多态性分两类:静态多态性和动态多态性。 静态多态性是通过函数...

      多态性(polymorphism)是面向对象程序设计的一个重要特征。在面向对象方法中,一般是这样表述多态性的:向不同的对象发送同一个消息,不同的对象在接收时会产生不同的行为。在C++中,多态性表现形式之一是:具有不同功能的函数可以用同一个函数名,这样就可以实现用一个函数名调用不同内容的函数。

      从系统实现的角度来看,多态性分两类:静态多态性动态多态性。 静态多态性是通过函数重载实现的。要求在程序编译时就知道调用函数的全部信息,因此,在程序编译时系统就能决定要调用的是哪个函数。动态多样性的特点是:不在编译时确定调用的是哪个函数,而是在程序运行过程中才动态地确定操作针对的对象。动态多态性是通过虚函数(virtual function)实现的。 

      本文先来介绍一下静态多态性,下面用一个例子简单介绍一下函数重载和函数覆盖。


    (程序会比较长,对于一个比较长的程序,应当分成若干步骤进行分析。)

    首先定义一个Point类作为基类:

    #ifndef POINT
    #define POINT
    #include
    using namespace std;
    
    class Point
    {public:
    Point(float x=0.0,float y=0.0);
    void setPoint(float,float);
    float getX()const{return x;};
    float getY()const{return y;};
    friend ostream & operator<<(ostream &output,const Point &p)//友元重载运算符<<
    {output<<"["<

    然后是定义Circle类,属于Point的公有派生类:

    #ifndef CIRCLE
    #define CIRCLE
    #include
    #include"Point.h"
    using namespace std;
    
    class Circle:public Point
    {public:
    Circle(float x=0.0,float y=0.0,float r=0.0);
    void setRadius(float);
    float getRadius()const;
    float area()const;
    friend ostream & operator<<(ostream &output,const Circle &c)//友元重载运算符<<
    {output<<"Center=["<

    然后是定义Cylinder类,属于Circle类的公有派生类:

    #ifndef CYLINDER
    #define CYLINDER
    #include
    #include"Circle.h"
    #include"Point.h"
    using namespace std;
    
    class Cylinder:public Circle
    {public:
    Cylinder(float x=0.0,float y=0.0,float r=0.0,float h=0.0);
    void setHeight(float);
    float getHeight() const;
    float area() const;
    float volume() const;
    friend ostream& operator<<(ostream &output,const Cylinder& cy)
    {output<<"Center=["<

    最后是main函数,测试这三个类:

    #include
    #include"Point.h"
    #include"Circle.h"
    #include"Cylinder.h"
    using namespace std;
    
    int main()
    {
        
    cout<<"测试Point类:"<


    测试结果如下图:



      下面我们来分析以上三个类:

      可以看出,在Point类中,我们声明了一次运算符“<<”重载函数,在Circle类中,我们又声明了一次运算符“<<”重载函数,两次重载的运算符“<<”内容是不一样的,在编译时编译系统会根据输出项的类型确定调用哪一个运算符重载函数,这属于静态多态性。

    (一)请注意main函数中的:Point &pRef=c;(例一处)

      该处定义了Point类的引用pRef,并用派生类Circle对象c对其初始化。Circle是Point的公用派生类,因此,对象c包括了公用基类部分和公用派生类新增部分,因为引用pRef被定义为Point类,所以,pRdf不能认为是代表了c,它只是代表了c中公用基类的部分。引用pRef得到了c的起始地址,与c中公用基类部分共享了同一段存储单元。所以用“cout<<pRef”输出时,调用的不是Circle中声明的运算符重载函数,而是在Point中声明的运算符重载函数,输出的是“点”的信息,而不是“圆“的信息。


    (二)请注意Cylinder类定义中的area函数(例二处)
      该处的area函数与Circle类中定义的area函数同名,在main函数调用cyl.area()(例三处)时,调用的是Cylinder类的area函数。这里两个类的area函数并不是重载函数,因为它们不仅函数名相同,而且函数类型和参数个数都相同,这样的两个函数不在同一个类中,而是分别在基类和派生类中,属于同名覆盖。


    (三)注意main函数中的:Point &ppRef=cyl;(例四处)和Circle &cRef=cyl;(例五处)

      与例一处相同,ppRef为cyl中属于Point类的那部分,cRef为cyl中属于Circle类的那部分。所以输出的分别是“点”和“圆”,而不是“圆柱”。

      

      在本文的程序中,有三个运算符函数时重载(不是同名覆盖),而在编译时,编译系统即可判定应该调用哪个重载运算符函数,这体现了静态多态性。



    参考资料:《C++程序设计与分析(第二版)》.谭浩强.清华大学出版社.2011.8.pag392-398

    展开全文
  • 多态性是指统一的接口,不同的表现形式。在我们下面的例子中,有5个类。 Game类是Football、Basketball、Popolong的父类,Games类使用前面4个类。 Java根据动态绑定决定执行“更具体”的方法,即子类方法。 ...
    
    

    多态性是指统一的接口,不同的表现形式。在我们下面的例子中,有5个类。

    Game类是Football、Basketball、Popolong的父类,Games类使用前面4个类。

    Java根据动态绑定决定执行“更具体”的方法,即子类方法。

    1. //Game.java
    2. package cn.edu.uibe.oop;
    3. public class Game {
    4.  protected void play(){
    5.   System.out.println("play game");
    6.  }
    7. }
    8. //Football.java
    9. package cn.edu.uibe.oop;
    10. public class Football extends Game {
    11.  protected void play() {
    12.     System.out.println("play football");
    13.     super.play();
    14.  }
    15.  void f(){
    16.   play();
    17.  }
    18. }
    19. //Basketball.java
    20. package cn.edu.uibe.oop;
    21. public class Basketball extends Game{
    22.  protected void play() {
    23.   System.out.println("play basketball");
    24.  }
    25. }
    26. //Popolong.java
    27. package cn.edu.uibe.oop;
    28. public class Popolong extends Game {
    29.  protected void play() {
    30.   System.out.println("play popolong");
    31.  }
    32. }
    33. //Games.java
    34. package cn.edu.uibe.oop;
    35. public class Games {
    36.  public static void main(String[] args) {
    37.   Game[] games = new Game[10];
    38.   games[0] = new Basketball();
    39.   games[1] = new Football();
    40.   games[2] = new Popolong();
    41.   
    42.   for(int i=0;i<games.length;i++){
    43.    if(games[i]!=null)
    44.       games[i].play();
    45.   }
    46.   
    47.  }
    48. }




     


    展开全文
  • 多态性

    2013-05-23 16:32:05
    多态性”一词最早用于生物学,指同一种族的生物体具有相同的特性。在面向对象的程序设计理论中,多态性的定义是:同一操作作用于不同的类的实例,将产生不同的执行结果,即不同类的对象收到相同的消息时,得到不同...
    “多态性”一词最早用于生物学,指同一种族的生物体具有相同的特性。在面向对象程序设计理论中,多态性的定义是:同一操作作用于不同的类的实例,将产生不同的执行结果,即不同类的对象收到相同的消息时,得到不同的结果。多态是面向对象程序设计的重要特征之一,是扩展性在“继承”之后的又一重大表现 。对象根据所接受的消息而做出动作,同样的消息被不同的对象接受时可能导致完全不同的行为,这种现象称为多态性。
    多态性包含编译时的多态性、运行时的多态性两大类。 即:多态性也分静态多态性和动态多态性两种。

    静态多态性

    静态多态性是指定义在一个类或一个函数中的同名函数,它们根据参数表(类型以及个数)区别语义,并通过静态联编实现,例如,在一个类中定义的不同参数的构造函数

    动态多态性

    动态多态性是指定义在一个类层次的不同类中的重载函数,它们一般具有相同的函数,因此要根据指针指向的对象所在类来区别语义,它通过动态联编实现。
    在用户不作任何干预的环境下,类的成员函数的行为能根据调用它的对象类型自动作出适应性调整,而且调整是发生在程序运行时,这就是程序的动态多态性。即,发出同样的消息被不同类型的对象接收时,有可能导致完全不同的行为。

    程序设计多态性的示例

    多态性就是多种表现形式,具体来说,可以用"一个对外接口,多个内在实现方法"表示。举一个例子,计算机中的堆栈可以存储各种格式的数据,包括整型,浮点或字符。不管存储的是何种数据,堆栈的算法实现是一样的。针对不同的数据类型,编程人员不必手工选择,只需使用统一接口名,系统可自动选择。
    举例子说明一下:
    #include <iostream>
    std::cout;
    class A {
    public:
    virtual void test() { cout<<"aaa"<<endl; } //运行时的多态性,如果不加virtual就是编译时的多态
    //void test() { cout<<"aaa"<<endl; }//编译时的多态性
    };
    class B:public A
    {
    public:
    void test() {cout<<"bbb"<<endl;}
    };
    class C:public B
    {
    public:
    void test() {cout<<"ccc"<<endl;}
    };
    void main()
    {
    C cc;
    A *p=&cc;
    p->test();
    }
    在Class A的test函数前加上virtual,即在运行时多态的时候,程序输出结果为:ccc
    在Class A的test函数前不加virtual,即在编译时多态的时候,程序输出结果为:aaa
    C++的多态性:在基类的函数前面加上Virtual关键字,在派生类中重写该函数,运行时将会根据对象的实际类型来调用相应的函数。如果对象类型派生类,就调用派生类的函数;如果对象类型是基类,就调用基类的函数。
    展开全文
  • 多态性的科学解释:允许你将父对象设置成为一个或更多的他子对象的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。 通俗的解释,就是一句话:可以把一个子类的对象转换为父类的对象...

    点击进入_更多_Java千百问

    1、什么是多态

    多态是对象具有多种表现形式的能力。
    在面向对象语言中,接口的多种不同的实现方式即为多态
    多态性的科学解释:允许你将父对象设置成为一个或更多的他子对象的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。
    通俗的解释,就是一句话:可以把一个子类的对象转换为父类的对象
    在Java中,所有的Java对象是多态的,因为任何对象都可以设置为自己本身的类和Object类(Object是所有类的父类)。

    了解跟多继承看这里:java类的继承有什么意义

    2、如果表现多态

    让我们来看一个例子。
    例子:

    public interface Vegetarian{}
    public class Animal{}
    public class Deer extends Animal implements Vegetarian{}

    现在,Deer类被认为是多态的,因为这有多重继承。于是:

    • 鹿is-a动物(is-a等于继承,了解更多is-a看这里:is-a,has-a,like-a是什么
    • 鹿like-a素食(is-a等于实现)
    • 鹿 is-a Object

    由于多态性,下面的声明是合法的:

    Deer d = new Deer();
    Animal a = d;
    Vegetarian v = d;
    Object o = d;

    所有d的参考变量d,a,v,o在堆中都指向相同的Deer对象。

    了解更多引用传递看这里:
    了解更多变量内存存储看这里:

    3、方法多态是什么

    我们知道方法覆盖,其中一个子类可以在其父覆盖的方法。即覆盖方法的本质是隐藏父类方法,除非子类使用的重载方法中的super关键字。无论子类以何种形态被声明,都会执行子类的方法,这就是方法的多态

    了解更多覆盖看这里:java中覆盖是什么
    了解更多重载和覆盖的区别看这里:java中重载和覆盖有什么关系
    例如:

    /* File name : Employee.java */
    public class Employee
    {
       private String name;
       private String address;
       private int number;
       public Employee(String name, String address, int number)
       {
          System.out.println("Constructing an Employee");
          this.name = name; 
          this.address = address;
          this.number = number;
       }
       public void mailCheck()
       {
          System.out.println("Mailing a check to " + this.name
           + " " + this.address);
       }
       public String toString()
       {
          return name + " " + address + " " + number;
       }
       public String getName()
       {
          return name;
       }
       public String getAddress()
       {
          return address;
       }
       public void setAddress(String newAddress)
       {
          address = newAddress;
       }
       public int getNumber()
       {
         return number;
       }
    }

    Salary类继承Employee类,如下所示:

    /* File name : Salary.java */
    public class Salary extends Employee
    {
       private double salary; //Annual salary
       public Salary(String name, String address, int number, double
          salary)
       {
           super(name, address, number);
           setSalary(salary);
       }
       public void mailCheck()
       {
           System.out.println("Within mailCheck of Salary class ");
           System.out.println("Mailing check to " + getName()
           + " with salary " + salary);
       }
       public double getSalary()
       {
           return salary;
       }
       public void setSalary(double newSalary)
       {
           if(newSalary >= 0.0)
           {
              salary = newSalary;
           }
       }
       public double computePay()
       {
          System.out.println("Computing salary pay for " + getName());
          return salary/52;
       }
    }

    测试代码:

    /* File name : VirtualDemo.java */
    public class VirtualDemo
    {
       public static void main(String [] args)
       {
          Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
          Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
          System.out.println("Call mailCheck using Salary reference --");
          s.mailCheck();
          System.out.println("
    Call mailCheck using Employee reference--");
          e.mailCheck();
        }
    }

    这将产生以下结果:
    Constructing an Employee
    Constructing an Employee
    Call mailCheck using Salary reference –
    Within mailCheck of Salary class
    Mailing check to Mohd Mohtashim with salary 3600.0

    Call mailCheck using Employee reference–
    Within mailCheck of Salary class
    Mailing check to John Adams with salary 2400.0

    结论如下:
    1. 在调用s.mailCheck()时,调用Salary类中的mailCheck()。
    2. 在调用e.mailCheck()时,由于e是Salary对象的一个引用,所以实际调用的是Salary类中的mailCheck()。
    3. 这种调用被称为虚拟方法调用,该方法被称为虚拟方法

    展开全文
  • C++中,多态性表现形式之一是:具有不同功能的函数可以用同一个函数名,这样就可以实现用同一个函数名调用不同内容的函数。 系统实现的角度: 静态多态性:通过函数重载实现,编译时的多态性,由函数重
  • C#中的多态性

    千次阅读 2020-01-30 19:24:10
    多态是指一个行为具有多个不同表现形式的能力,在C#中通过多态性的检测时机可以分为静态多态性和动态多态性静态多态性:函数重载和运算符重载 动态多态性:抽象方法、重写方法、隐藏方法 二:函数重载(overlode) ...
  • java多态性

    千次阅读 2016-12-03 19:01:01
    多态的两种表现形式:方法重载overloading(静态多态性) 方法覆盖overriding (动态多态性) 方法的重载在Java中每个方法都有签名,就是方法名以及参数的个数和类型。如果两个方法参数的个数或类型不同,它们可以...
  • 多态性多态性就是多种表现形式,具体来说,可以用"一个对外接口,多个内在实现方法"表示。举一个例子,计算机中的堆栈可以存储各种格式的数据,包括整型,浮点或字符。不管存储的是何种数据,堆栈的算法实现是...
  • 【C#】多态性

    2017-11-16 09:59:48
    多态性意味着有多重形式。在面向对象编程范式中,多态性往往表现为"一个接口,多个功能"。 多态性可以是静态的或动态的。在静态多态性中,函数的响应是在编译时发生的。在动态多态性中,函数的响应是在运行时发生的...
  • 多态性定义

    千次阅读 2010-09-07 10:35:00
    多态性就是多种表现形式,具体来说,可以用"一个对外接口,多个内在实现方法"表示。举一个例子,计算机中的堆栈可以存储各种格式的数据,包括整型,浮点或字符。不管存储的是何种数据,堆栈的算法实现是一样的...
  • 多态性和虚函数

    千次阅读 2018-07-01 11:16:53
    具体的说,它主要表现在函数调用时,实现一种接口,多种方法,多态性是面向对象程序设计的另一个重要特征。C++支持两种多态性,编译时多态性和运行时的多态性。 编译时的多态性指的是属于某个类的不同对象,或不同...
  • Java多态性(向上转型、向下转型)

    千次阅读 多人点赞 2018-11-05 17:26:44
    文章目录多态1.1 方法的多态性1.2 对象的多态性(抽象类和接口)1.2.1 对象的向上转型1.2.2 对象的向下转型1.2.3 一个向上转型的实例1.3 多态性的总结 多态 在Java中,对于多态的核心表现主要有一下两点: 1.1 方法...
  • scala之高阶函数多态性

    千次阅读 2019-05-13 17:26:50
    三:scala中的多态性 一:多态 是同一个行为具有多个不同表现形式或形态的能力 就是同一个接口,使用不同的实例而执行不同操作 二:java 中的多态 方式一:重写: 这个内容已经在上一章节详细讲过,就不再阐述...
  • C++多态性原理

    2011-05-08 20:16:00
    C++多态性  两种表现形式:静态多态性 通过一般的函数重载来实现。  动态多态性 通过虚函数来实现。  静态多态性比较简单,主要动态多态性比较难理解。  动态多态性有两个条件:...
  • C++多态性原理

    2010-12-19 19:06:00
    C++多态性 两种表现形式:静态多态性 通过一般的函数重载来实现。 动态多态性 通过虚函数来实现。 静态多态性比较简单,主要动态多态性比较难理解。 动态多态性有两个条件: 1、在基类中必须使用虚函数、纯虚...
  • 理解误区——方法的重载是多态性的一种体现? 方法的重载是多态性的一种体现吗? 其实这是一个误区,让我很长的一段时间都理解错了,直到又一次系统复习Java的时候才理解,方法的重载并不是是多态性的一种体现. 什么...
  • 多态性

    2009-03-10 18:28:00
    baike.baidu.com/view/261058.htm  多态性就是多种表现形式,具体来说,可以用"一个对外接口,多个内在实现方法"表示。举一个例子,计算机中的堆栈可以存储各种格式的数据,包括整型,浮点或字符。不管存储的是何...
  • C++中的多态性

    2012-09-06 14:39:01
    c++中的多态性可以有两种表现形式: 面向对象编程中的多态性:(继承关系中的多态性)在继承关系中的基类中指定某函数为虚函数(virtual),接着在函数调用中使用基类的引用或者指针作为形参,如果在调用该函数时...
  • C++的多态性

    2007-08-01 09:20:00
    C++的多态性 1.多态性的概念 多态性是指用一个名字定义不同的函数,这函数执行不同但又类似的操作,从而实现“一个接口,多种方法”。多态性的实现与静态联编、动态联编有关。静态联编支持的多态性称为编译时的多态...
  • 习题五 多态性和虚函数

    千次阅读 2018-06-27 21:54:00
    一、填空题(1)C++的两...(3)重载函数在编译时表现多态性,就是 静态 联编;而虚函数则在运行时表现多态性是 动态 联编。(4)为了区分重载函数,把一个派生类中重定义基类的虚函数称为 覆盖 。(5)如...
  • C++多态性,虚函数,重载,抽象类

    千次阅读 2016-07-21 14:55:17
    1,C++多态性,虚函数,重载,比较有意思,,,,,, 在面向对象的程序中,当不同的对象接受到相同的消息产生不同的动作,这种性质称为多态性
  • C++中的多态性表现形式:具有不同功能的函数可以用同一个函数名(同一个函数名的含义是,函数的各部分都相同,不然就会发生函数重载,而这里并不是指函数重载!),这样就可以实现用一个函数名调用不同内容的函数。 ...
  • C++基础#12:多态性与虚函数

    千次阅读 2009-11-12 08:02:00
    多态性概念:在面向对象的概念中,多态性是指不同对象接收到相同消息时,根据对象类的不同产生不同的动作。多态性提供了同一个接口可以用多种方法进行调用的机制,从而可以通过相同的接口访问不同的函数。具体地说,...
  • C++的多态性

    千次阅读 2005-06-25 22:47:00
    1.多态性的概念 多态性是指用一个名字定义不同的函数,这函数执行不同但又类似的操作,从而实现“一个接口,多种方法”。多态性的实现与静态联编、动态联编有关。静态联编支持的多态性称为编译时的多态性,也称静态...
  • Java的多态性

    千次阅读 2011-09-06 19:31:10
    面向对象编程有三个特征,即封装、继承和多态。 封装隐藏了类的内部实现机制,从而可以在不... 继承是为了重用父类代码,同时为实现多态性作准备。那么什么是多态呢? 方法的重写、重载与动态连接构成多态性。Ja
  • C++ 多态性的实现方式

    千次阅读 2013-11-04 18:03:29
     多态性是面向对象程序设计的一大支柱,它指的是在基类中定义的属性或服务被派生类继承之后,可以表现出不同的行为. 也就是指一段程序能够处理不同类型对象的能力. 在面向对象程序设计语言C + + 中,这种多态性的实现...
  • 一、填空题(1)C++的两...(3)重载函数在编译时表现多态性,就是 ( 静态 )联编;而虚函数则在运行时表现多态性是 ( 动态 ) 联编。(4)为了区分重载函数,把一个派生类中重定义基类的虚函数称为 ( 覆...
  • 一、填空题(1)C++的两...(3)重载函数在编译时表现多态性,就是 ( 静态 )联编;而虚函数则在运行时表现多态性是 ( 动态 ) 联编。(4)为了区分重载函数,把一个派生类中重定义基类的虚函数称为 ( 覆...
  • java多态性Overload和Override的区别

    千次阅读 2013-10-14 09:26:31
    最近看了一下关于java的基础知识,对此作了一下搜集整理:  java中的继承,方法覆盖(重写)...重写(Overriding)是父类与子类之间多态性的一种表现,而重载(Overloading)是一个类中多态性的一种表现。如果在子类中
  • Java多态性的例子

    万次阅读 2008-10-25 09:20:00
    多态性是指统一的接口,不同的表现形式。在我们下面的例子中,有5个类。Game类是Football、Basketball、Popolong的父类,Games类使用前面4个类。Java根据动态绑定决定执行“更具体”的方法,即子类方法。//Game.java...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,056
精华内容 13,222
关键字:

多态性的表现形式