精华内容
下载资源
问答
  • 多态性和函数应用C++语言程序设计 多态性和函数应用C++语言程序设计 多态性和函数应用 C++语言程序设计 多态性和函数应用C++语言程序设计 本章主要内容 多态性 运算符重载 虚函数 纯虚函数 抽象类 多态性和函数应用...
  • 主要介绍了Java面向对象程序设计多态性,结合实例形式分析了java多态性的概念、原理、定义与使用方法及相关注意事项,需要的朋友可以参考下
  • 第九章 虚函数和多态性;9.1 问题引入;9.1 问题引入;9.1 问题引入;9.2 多态性的概念;9.2 多态性的概念;9.2 多态性的概念;9.2 多态性的概念;9.2 多态性的概念;9.2 多态性的概念;9.3 实现多态性的基石虚函数;9.3 实现...
  • 主要介绍了PHP面向对象程序设计之多态性的应用,结合具体实例形式分析了php面向对象程序设计中关于多态性的概念、原理、相关使用技巧及注意事项,需要的朋友可以参考下
  • C++程序设计第13章多态性与虚函数C++程序设计第13章多态性与虚函数
  • The C++ Programming Language 面向对象的程序设计 Object-oriented Programming C++ 程序设计 第9讲 多态性和虚函数 Chapter 9 Polymorphism and virtual function 第9章 多态性和虚函数 polymorphism and virtual ...
  • 多态性

    2019-10-02 15:17:46
    多态性 1.多态性指的是什么? 多态性,可以理解为一个事物的多种表现形态。  1.1方法的重载与重写  1.2子类对像的多态性 2.子类对像的多态性使用的前提  2.1要有类的继承  2.2要有子类对父类方法的重写 ...



    lesson Eleven                        2018-04-30  22:34:59




    多态性

    1.多态性指的是什么?   多态性,可以理解为一个事物的多种表现形态。

      1.1方法的重载与重写

      1.2子类对像的多态性

    2.子类对像的多态性使用的前提

      2.1要有类的继承

      2.2要有子类对父类方法的重写

    3.程序运行分为编译状态和运行状态

      如:Person p = new Person();

      3.1对于多态性来说,编译时,检测等号左边,将此引用变量理解为父类的类型。

      3.2对于多态性来说,运行时,检测等号右边,关注于真正对像的实体,子类的对像。执行的方法

     1 public class Person {
     2     private String name;
     3     private int age;
     4     int id = 1001;
     5 
     6     public String getName() {
     7         return name;
     8     }
     9 
    10     public void setName(String name) {
    11         this.name = name;
    12     }
    13 
    14     public int getAge() {
    15         return age;
    16     }
    17 
    18     public void setAge(int age) {
    19         this.age = age;
    20     }
    21 
    22     public void eat() {
    23         System.out.println("eating");
    24     }
    25 
    26     public void walk() {
    27         System.out.println("walking");
    28     }
    29 
    30 }
    父类

    4.虚拟方法调用:通过父类的引用指向子类的对像实体,当调用方法时,实际执行的是子类重写父类的方法

    5.父类引用指向子类实体后,不可以调用子类独有的方法和属性。

    6.子类对像的多态性并不适用于属性。

     1 public class man extends Person {
     2 
     3     int id = 1002;
     4 
     5     public void eat() {
     6         System.out.println("man is eaeting!");
     7     }
     8 
     9     public void walk() {
    10         System.out.println("man is walking");
    11     }
    12 
    13     public void playGame() {
    14         System.out.println("man is playing games");
    15     }
    16 }
    子类

     1 public static void main(String[] args) {
     2         Person p = new Person();
     3         p.eat();
     4         p.walk();
     5         System.out.println();
     6 
     7         man m = new man();
     8         m.eat();
     9         m.walk();
    10         System.out.println();
    11         
    12         //子类对像的多态性:父类的引用指向子类对像
    13         Person p1 = new man();
    14         //虚拟方法调用:通过父类的引用指向子类的对像实体,当调用方法时,实际执行的是子类重写父类的方法
    15         p1.walk();
    16         p1.eat();
    17         System.out.println(p.id);
    18 //        p1.playGame();
    19 //        不可以调用子类独有的方法和属性。
    20     }
    主方法



     

    转载于:https://www.cnblogs.com/Fkuennhvo/p/8975077.html

    展开全文
  • 第 13 章 多态性 13.1 函数重载 13.2 运算符重载 13.3 静态联编 13.4 动态联编和虚函数 13.5 纯虚函数和抽象类 ;第 13 章 多态性 ;13.1 函数重载 参见5.6节略 ; 允许重载 和 不允许重载的运算符见13-1和13-2表;1....
  • 程序语言多态性理解

    2013-09-03 20:19:36
    多态性,顾名思义是多种状态的性质。 在面向对象的编程语言中,子类通过实现父类当中的抽象方法,实现了多个子类对于同一种方法的多种不同实现,在传递父类指针或引用时,即可调用不同子类的实现方法。 在java语言...

    多态性,顾名思义是多种状态的性质。

    在面向对象的编程语言中,子类通过实现父类当中的抽象方法,实现了多个子类对于同一种方法的多种不同实现,在传递父类指针或引用时,即可调用不同子类的实现方法。

    在java语言中,变量的实体类型也可以看做是多态的实现。每一个变量的实体类型(Integer,String,Float,或是自己定义的class),均继承于Object,在Object中有这些实体类型的equals和hashcode的通用实现,必要时进行重写,所以可见,对象中保存着有关自己种类的信息,但又有其父类通用的实现,这就是为什么在进行Integer类型的比较时,要用A.equals(B),而不能用==。

    对于像ruby,lisp这一类的动态编程语言来说,某个变量可以用各种类型的数据来赋值,程序执行时可以根据数据类型的不同来自动选择合适的处理方法,因此可以看做是变量多态性的一种体现,执行时才会进行类型检查,所以一旦发现有不正确的处理,程序就会停止执行。但是不执行程序的话是无法知道哪儿有错误的。

    展开全文
  • 一,多态性概述 二,运算符重载 三,虚函数 四,纯虚函数与抽象类 五,深度探索

    一,多态性概述

    同样的消息被不同类型的对象接收时导致不同的行为

    1,多态的类型

    (1)专用多态

    1:重载多态
    2:强制多态

    (2)通用多态

    1:参数多态
    2:包含多态

    2,多态的实现

    1:编译时多态
    2:运行时多态
    3:绑定:确定操作的具体对象的过程
    4:动态绑定:程序编译连接阶段完成
    5:静态绑定:程序运行阶段完成

    二,运算符重载

    1,运算符重载的规则

    2,运算符重载为成员函数

    3,运算符重载为非成员函数

    三,虚函数

    1,一般虚函数成员

    virtual 函数类型 函数名(形参表);

    2,虚析构函数

    virtual ~类名();

    四,纯虚函数与抽象类

    1,纯虚函数

    virtual 函数类型 函数名(形参表)=0;

    2,抽象类

    五,深度探索

    展开全文
  • 第12章 虚函数与多态性12.1 多态性的概念12.2 虚函数的定义12.3 抽象类12.4 实例研究12.1 多态性(polymorphism)的概念多态性是OOP的重要特征之一多态一词最初来源于希腊语Polumorphos含义是具有多种形式或形态的情形...
  • 1.多态性的概念 多态性:向不同的对象发送同一个消息,不同的对象在接收时会产生不同 的行为。 静态多态性:由函数中在和运算符重载形成。 动态多态性:通过虚函数实现。 2.示例 先建立一个Point类,包含数据成员x,...

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档


    一.多态性的概念

    多态性:向不同的对象发送同一个消息,不同的对象在接收时会产生不同 的行为。
    静态多态性:由函数中在和运算符重载形成。
    动态多态性:通过虚函数实现。

    二.示例

    先建立一个Point类,包含数据成员x,y(坐标点)。以它为基类,派生出一个Circle(圆)类,增加数据成员r(半径),再以Circle类为直接基类,派生出一个Cylinder(圆柱体)类,再增加数据成员h(高)。要求编写程序,重载运算符“<<",">>",使之用于输出一上类对象。

    声明类Point
    #include<iostream>
    using namespace std;
    class Point 
    {
    	public:
    		Point(float x=0,float y=0);//有默认值的构造函数 
    		void setPoint(float,float);//设置坐标值  
    		float getX() const {return x;}//读x坐标,getX函数为常成员函数
    		float getY() const {return y;}
    		friend ostream&operator<<(ostream&,const Point&);//友元重载运算符<<
    	protected:
    	    float x,y; 
     } ;
     Point::point(float a,float b)//对x,y初始化
     {
     	x=a;y=b;
     }
     void Point::setPoint(float a,float b)对x,y赋值
     {
     	x=a;y=b;
      } 
    ostream&operator<<(ostream&output,const Point&p)
    {
    	output<<"["<<p.x<<","<<p.y<<"]"<<endl;
    	return output;
    }
    
    声明派生类Circle
    class Circle:public Point 
    {
    	public:
    		Circle(float=0,float y=0,float r=0);//构造函数
    		void setRadius(float);//设置半径
    		float getRadius()const;//读取半径
    		float area()const;//计算圆面积
    		friend ostream&operator<<(ostream&,const Circle&);//重载运算符
    	private:
    	  float radius; 
    };
    Circle::Circle(float a,float b,float r):Point(a,b),radius(r){}//定义构造函数,对圆心坐标和半径初始化
    void Circle::setRadius(float r)//设置半径值
    {
    	radius=r;
      } 
    float Circle::getRadius() const{return radius;}//读取半径
    float Circle::area() const//计算面积
    {
    	return 3.14159*radius*radius;
     }
    ostream&operator<<(ostream&output,const Circle&c)//重载运算符
    {
    	output<<"Center=["<<c.x<<","<<c.y<<"],r="<<c.radius<<",area="<<c.area()<<endl;
    	return output;
     } 
    
    

    派生类对象可以代替基类对象的引用初始化或赋值

    声明Circle的派生类Cylinder
    class Cylinder:public Circle
    {
    	public :
    		Cylinder(float x=0,float y=0,float r=0,float h=0);//构造函数 
    		void sethight(float);//设置圆柱高 
    		float gethight();//读取圆柱高 
    		float area()const;//计算圆柱表面积 
    		float volume()const;//计算圆柱体积 
    		friend ostream&operator<<(ostream&,const Cylinder&);//重载运算符 
    	protected:
    		float height;
    }
    Cylinder::Cylinder(float a,float b,float r,float h):Circle(a,b,r),height(h){}
    
    void Cylinder::sethight(float h)
    {height=h;}
    
    float Cylinder::gethight() const
     {return height;}
    
    float Cylinder::area() const
    {return 2*Circle::area()+2*3.14159*radius*height}
    
    float Cylinder::volume() const
    {return 2*Circle::area()*height;}
    
    ostream&operator<<(ostream&output,Cylinder&cy)
    {
    	output<<"center="<<cy.x<<","<<cy.y.....;return putput;   } 
    

    Cylinder类中定义的area函数与Circle类中的area函数同名,且函数类型、参数个数相同,属于同名覆盖。

    三.利用 虚函数 实现动态多态性

    在函数最左边加一个关键字virtual

    virtual void display();
    

    作用:

    • 在基类中的display被声明为虚函数,在声明派生类时被重载,这时派生类的同名函数display就取代了其基类中的虚函数。
    • 当把基类的某个成员函数声明为虚函数后,允许其派生类中对该函数重新定义,赋予他新的功能,并且可以通过指向基类的指针指向同一类族的中的不同类的对象,从而调用其中的同名函数

    虚函数使用方法

    1. 在基类中用virtual声明成员函数为虚函数,在类外定义虚函数时不必再加virtual
    2. 在派生类重新定义此函数,函数名、函数类型、函数参数个数和类型必须与虚函数相同。
    3. 通过指针变量调用此虚函数,此时调用的就是指针变量指向的对象的同名函数。

    虚函数处理的是不同派层次上的同名函数的问题,理解为纵向重载。

    静态动态关联
    静态关联:在编译时即可确定其调用的虚函数属于哪一类。
    动态关联:在运行阶段,基类指针变量指向了某一个类的对象,然后通过此指针变量调用该对象的函数。

    四.纯虚函数与抽象类

    纯虚函数:只有函数名字而不具备函数的功能,不能被调用。在这里声明一个虚函数,留待派生类中定义。
    一般形式:
    virtual 函数类型 函数名(参数表)=0;

    virtual float area()const =0;
    

    抽象类:往往有一些类不用来生成对象。定义这些类的唯一目的是用它作为基类去建立派生类。

    示例:
    class Shap
    {public:
      virtual float area()const=0{return 0.0;}
      virtual float volume(const=0{return 0.0;}
      };
      
    
    展开全文
  • 程序性细胞死亡因子1基因单核苷酸多态性与中国扩张型心肌病的相关性研究,杨浩,彭瑛,目的 研究程序性细胞死亡因子1基因( programmed cell death 1,PDCD-1)单核苷酸多态性(single nucleotide polymorphisms,...
  • 多态性的优点多态性能够从一定程度上消除类型之间的耦合关系,通过统一接口方式,不同类的对象可以直接替换,程序更加灵活,可扩展。面向对象多态性存在的三个必要条件继承重写父类引用指向子类对象多态性的实现方式...
  • 第九章 多态性;2020/4/15 Wednesday;2020/4/15 Wednesday;2020/4/15 Wednesday;2020/4/15 Wednesday;2020/4/15 Wednesday;2020/4/15 Wednesday;2020/4/15 Wednesday;2020/4/15 Wednesday;2020/4/15 Wednesday;2020/4...
  • 多态性(一)——静态多态性

    千次阅读 2015-03-04 12:18:55
    多态性(polymorphism)是面向对象程序设计的一个重要特征。在面向对象方法中,一般是这样表述多态性的:向不同的对象发送同一个消息,不同的对象在接收时会产生不同的行为。在C++中,多态性表现形式之一是:具有...
  • 面向对象程序设计的三大特性:继承性,封装性,多态性。 阅读本文前,依然需要思考这些问题,并带着它们阅读: 什么是多态性? 强调:不要在程序当中使用同名的成员域。这不仅与多态性无关,还会造成错误。 1.静态...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,761
精华内容 1,904
关键字:

多态性程序