精华内容
下载资源
问答
  • 多态概念和实现

    2021-06-05 13:44:59
    多态概念和实现 多态(因人而异)指的是同一时期方法调用,由于对象不同可能会有不同的行为。 多态的要点 1.多态的方法是多态,不是属性的多态(堕胎与属性无关)。 2.多态的存在要三个必要条件:继承、方法...

    多态的概念和实现

    多态(因人而异)指的是同一时期方法调用,由于对象不同可能会有不同的行为。

    多态的要点

    1.多态的方法是多态,不是属性的多态(堕胎与属性无关)。

    2.多态的存在要三个必要条件:继承、方法的重写、父类引用指向对象。

    3.父类引用指向子类对象后,用该父类引用调用子类重写的方法,此时多态就出现了。

    例子演示:

    (1)

    public class Animal {
        public void shout(){
            System.out.println("叫了一声");
        }
    }
    
    class Dog extends Animal{
        @Override
        public void shout(){
            System.out.println("汪汪汪!");
        }
    }
    class Cat extends Animal{
        @Override
        public void shout(){
            System.out.println("喵喵喵!");
        }
    }
    
    class Mouse extends Animal{
    
    }
    

    (2)

    public class Test {
    
        static void animalCry(Animal a) {
            a.shout();    //多态
        }
    
        public static void main(String[] args) {
            Dog d = new Dog();
            animalCry(d);
            animalCry(new Cat());
        }
    }
    

    展开全文
  • JAVA中多态性是对象多种表现形式的体现。在面向对象中,最常见的多态发生在使用父类的引用来引用子类的对象。下面这篇文章主要给大家介绍一下,需要的朋友可以参考下
  • 主要介绍了进一步理解Java中的多态概念,是Java入门学习中的基础知识,需要的朋友可以参考下
  • C++多态概念和意义

    千次阅读 多人点赞 2020-09-04 10:12:31
    2、C++如何支持多态概念 3、多态内部运行剖析 4、多态的意义 5、修改示例代码 四、静态联编和动态联编 五、小结 一、什么叫重写 1、子类中可以重定义父类中已经存在的成员函数; 2、这种重定义发生在继承中...

    目录

    一、什么叫重写

    二、面向对象期望的重写

    1、示例分析

    2、所期望的重写

    三、多态的概念和意义

    1、多态的概念

    2、C++如何支持多态概念

    3、多态内部运行剖析

    4、多态的意义

    5、修改示例代码

    四、静态联编和动态联编

    五、小结


    一、什么叫重写

    1、子类中可以重定义父类中已经存在的成员函数;

    2、这种重定义发生在继承中,叫做函数重写;

    3、函数重写是同名覆盖的一种特殊情况。

    二、面向对象期望的重写

    先来验证个小示例:

    #include <QCoreApplication>
    #include <iostream>
    #include <QDebug>
    
    using namespace std;
    
    class Parent
    {
    
    public:
    
        void Printfln()
        {
            std::cout << "Parent: void Printfln()..." << std::endl;
        }
    };
    
    class Child : public Parent
    {
    public:
    
        void Printfln()
        {
            std::cout << "Child: void Printfln()..." << std::endl;
        }
    };
    
    void run(Parent *p)
    {
        p->Printfln();
    }
    
    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);
    
        Parent p;
        Child c;
    
        run(&p);
        run(&c);
    
        return a.exec();
    }
    

    1、示例分析

    1、结果:结果是调用两次run函数打印的结果相同;

    2、分析:

    (1)编译期间,编译器只能根据指针的类型判断所指向的对象;

    (2)根据赋值兼容性原则,编译器认为父类指针指向的是父类对象;

    (3)run函数中的指针p,编译器不可能知道它指向的究竟是什么,但是编译器没理由报错,编译器认为最安全的做法就是调用父类Printfln()函数,因为父类和子类都有相同的Printfln()函数;

    (4)因此,编译器结果只可能是调用父类定义的同名函数。

    2、所期望的重写

    面向对象的期望重写行为:根据实际的对象类型来判断如何调用重写函数

    (1)当父类指针(引用)指向父类对象,则调用父类中定义的成员函数;

    (2)当父类指针(引用)指向子类对象,则调用子类中定义的重写函数。

    三、多态的概念和意义

    1、多态的概念

    (1)根据实际的对象类型决定函数调用的具体目标;

    (2)同样的调用语句在实际运行时有多种不同的表现形态体现,这就是多态,同一语句具有多种形态。

    2、C++如何支持多态概念

    (1)通过使用virtual关键字对多态进行支持;

    (2)被virtual修饰的函数被重写后具有多种不同的表现形态;

    (3)被virtual声明的函数称为虚函数。

    3、多态内部运行剖析

    父类和子类的对象,首地址都各自有一个虚函数表地址,该地址都保存着虚函数Printfln()的地址,在运行过程中

    (1)在父类指针(引用)p,指向父类对象,就相当于指向父类的虚函数表,从而在父类的虚函数表中找到Printfln()函数;

    (2)在父类指针(引用)p,指向子类对象,相当于指向子类的虚函数表,从而在子类的虚函数表中找到Printfln()函数。

    4、多态的意义

    (1)在程序运行中展现出动态的特性;

    (2)函数重写必须多态实现,否则没有任何意义;

    (3)多态是面向对象组件化程序设计的基础特性。

    5、修改示例代码

    根据多态的概念,在程序中给父子类同名函数声明virtual关键字,只需要在父类中声明即可,在子类中可以不写,写了也是对的,编译器不会报错。

    #include <QCoreApplication>
    #include <iostream>
    #include <QDebug>
    
    using namespace std;
    
    class Parent
    {
    
    public:
    
        virtual void Printfln()
        {
            std::cout << "Parent: void Printfln()..." << std::endl;
        }
    };
    
    class Child : public Parent
    {
    public:
    
        void Printfln()
        {
            std::cout << "Child: void Printfln()..." << std::endl;
        }
    };
    
    void run(Parent *p)
    {
        p->Printfln();
    }
    
    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);
    
        Parent p;
        Child c;
    
        run(&p);
        run(&c);
    
        return a.exec();
    }
    

    四、静态联编和动态联编

    1、静态联编:程序编译期间就能确定的具体的函数调用,如函数重载;

    2、动态联编:程序运行期间才能确定的具体的函数调用,如函数重写。

    五、小结

    1、函数重写只能发生在父类和子类之间;

    2、多态是根据实际对象类型确定调用具体的函数;

    3、virtual关键字是C++支持多态的唯一方式;

    4、被重写的虚函数具有多种不同表现形态。

    展开全文
  • 面向对象多态概念理解

    千次阅读 2018-05-21 20:11:46
    1. 什么是多态一句话概括:父类对象引用子类变量 调用的是子类的实现例子:子类public class Chinese extends Person{ public void hello() { System.out.println("我是中国人"); } public void ...

    什么是多态

    一句话概括:父类对象引用子类变量 调用的是子类的实现

    例子:chinese 类 以及chinese的父类person ,调用chinese类的实现。

    子类

    public class Chinese extends Person{
    
    	public void hello()
    	{
    		System.out.println("我是中国人");
    	}
    	public void baimian()
    	{
    		System.out.println("我来拜年了");
    	}
    	
    }
    

    父类:

    public class Person {
    
    	public void hello()
    	{
    		System.out.println("我是人类");
    	}
    

    主程序:

    public class main {
    
    	
    	public static void main(String []args)
    	{
    		
    		Person p =new Chinese();
    		p.hello();//实际指向的对象是chinese的对象,调用的是子类的对象
    		//能调用什么方法取决于变量的类型
    		//所以没有bainian这个方法
    		
    		
    	}
    	
    }
    

    总结 :父类变量指向子类的对象的时候,实现实际上是实现子类的方法,但是能调用什么方法取决于父类的变量是什么类型的,题中无法调用子类的bainian方法


    根据传入的参数决定创建什么类型的对象

    public static Person createPerson(int i)
    	{
    		
    		if(i==3)
    		{
    			return new Chinese();
    		}
    		else
    		{
    			return new Person();
    		}
    		
    	}

    主程序执行这句话后结果是?

    Person p2=createPerson(3);
    p2.hello();

    结果:




    展开全文
  • C++封装继承多态总结 面向对象的三个基本特征 面向对象的三个基本特征是:封装、继承、多态。其中,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了——代码重用...

       

    C++封装继承多态总结

    面向对象的三个基本特征

    面向对象的三个基本特征是:封装、继承、多态。其中,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用!

    封装                                                                                                                                                                   

    什么是封装?

    封装可以隐藏实现细节,使得代码模块化;封装是把过程和数据包围起来,对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念,即现实世界可以被描绘成一系列完全自治、封装的对象,这些对象通过一个受保护的接口访问其他对象在面向对象编程上可理解为:把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。

    继承                                                                                                                                                                      

    什么是继承?

    继承是指这样一种能力:它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。其继承的过程,就是从一般到特殊的过程。

    通过继承创建的新类称为“子类”或“派生类”。被继承的类称为基类父类超类。要实现继承,可以通过继承Inheritance)和组合Composition)来实现。在某些 OOP 语言中,一个子类可以继承多个基类。但是一般情况下,一个子类只能有一个基类,要实现多重继承,可以通过多级继承来实现。

    继承的实现方式?

    继承概念的实现方式有三类:实现继承、接口继承和可视继承

    1. 实现继承是指使用基类的属性和方法而无需额外编码的能力;

    2. 接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力;

    3. 可视继承是指子窗体(类)使用基窗体(类)的外观和实现代码的能力。

    多态                                                                                                                                             

    什么是多态?

    多态性(polymorphisn)是允许你将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针

    例子:(2012某**软件公司笔试题)

    请按顺序写出下面代码的输出结果:

    答案:call child func

    call ~child

    call ~base

    多态的实现方式分析?

    实现多态,有二种方式,覆盖,重载。覆盖:是指子类重新定义父类的虚函数的做法。重载:是指允许存在多个同名函数,而这些函数的参数表不同(或许参数个数不同,或许参数类型不同,或许两者都不同)。

    分析:

    重载”是指在同一个类中相同的返回类型和方法名,但是参数的个数和类型可以不同

    覆盖\重写”是在不同的类中。

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

    C++多态机制的实现:

    该部分转自:http://blog.chinaunix.net/uid-7396260-id-2056657.html

    1c++实现多态的方法

    面向对象有了一个重要的概念就是对象的实例,对象的实例代表一个具体的对象,故其肯定有一个数据结构保存这实例的数据,这一数据包括对象成员变量,如果对象有虚函数方法或存在虚继承的话,则还有相应的虚函数或虚表指针,其他函数指针不包括。

    虚函数在c++中的实现机制就是用虚表和虚指针,但是具体是怎样的呢?从more effecive c++其中一篇文章里面可以知道:是每个类用了一个虚表,每个类的对象用了一个虚指针。要讲虚函数机制,必须讲继承,因为只有继承才有虚函数的动态绑定功能,先讲下c++继承对象实例内存分配基础知识:

    从more effecive c++其中一篇文章里面可以知道:是每个类用了一个虚表,每个类的对象用了一个虚指针。具体的用法如下:
    class A
    {public:
        virtual void f();
        virtual void g();
    private:
        int a
    };

    class B : public A
    {
    public:
        void g();
    private:
        int b;
    };
    //A
    ,B的实现省略
    因为A有virtual void f(),和g(),所以编译器为A类准备了一个虚表vtableA,内容如下:

     

    A::f 的地址

    A::g 的地址

    B因为继承了A,所以编译器也为B准备了一个虚表vtableB,内容如下:

    A::f 的地址

    B::g 的地址

    注意:因为B::g是重写了的,所以B的虚表的g放的是B::g的入口地址,但是f是从上面的A继承下来的,所以f的地址是A::f的入口地址。然后某处有语句 B bB;的时候,编译器分配空间时,除了A的int a,B的成员int b;以外,还分配了一个虚指针vptr,指向B的虚表vtableB,bB的布局如下:

    vptr : 指向B的虚表vtableB

    int a: 继承A的成员

    int b: B成员


    当如下语句的时候:
    A *pa = &bB;
    pa
    的结构就是A的布局(就是说用pa只能访问的到bB对象的前两项,访问不到第三项int b)
    那么pa->g()中,编译器知道的是,g是一个声明为virtual的成员函数,而且其入口地址放在表格(无论是vtalbeA表还是vtalbeB表)的第2项,那么编译器编译这条语句的时候就如是转换:call *(pa->vptr)[1](C语言的数组索引从0开始哈~)。
    这一项放的是B::g()的入口地址,则就实现了多态。(注意bB的vptr指向的是B的虚表vtableB)
    另外要注意的是,如上的实现并不是唯一的,C++标准只要求用这种机制实现多态,至于虚指针vptr到底放在一个对象布局的哪里,标准没有要求,每个编译器自己决定。我以上的结果是根据g++ 4.3.4经过反汇编分析出来的。
    2、两种多态实现机制及其优缺点

    除了c++的这种多态的实现机制之外,还有另外一种实现机制,也是查表,不过是按名称查表,是smalltalk等语言的实现机制。这两种方法的优缺点如下:
    (1)按照绝对位置查表这种方法由于编译阶段已经做好了索引和表项(如上面的call *(pa->vptr[1]) ),所以运行速度比较快;缺点是:当A的virtual成员比较多(比如1000个),而B重写的成员比较少(比如2个),这种时候,B的vtableB的剩下的998个表项都是放A中的virtual成员函数的指针,如果这个派生体系比较大的时候,就浪费了很多的空间。
    比如:GUI库,以MFC库为例,MFC有很多类,都是一个继承体系;而且很多时候每个类只是1、2个成员函数需要在派生类重写,如果用C++的虚函数机制,每个类有一个虚表,每个表里面有大量的重复,就会造成空间利用率不高。于是MFC的消息映射机制不用虚函数,而用第二种方法来实现多态,那就是:
    (2)、按照函数名称查表
    ,这种方案可以避免如上的问题;但是由于要比较名称,有时候要遍历所有的继承结构,时间效率性能不是很高。(关于MFC的消息映射的实现,看下一篇文章)
    3、总结:

    如果继承体系的基类的virtual成员不多,而且在派生类要重写的部分占了其中的大多数时候,用C++的虚函数机制是比较好的;但是如果继承体系的基类的virtual成员很多,或者是继承体系比较庞大的时候,而且派生类中需要重写的部分比较少,那就用名称查找表,这样效率会高一些,很多的GUI库都是这样的,比如MFC,QT
    PS 其实,自从计算机出现之后,时间和空间就成了永恒的主题,因为两者在98%的情况下都无法协调,此长彼消;这个就是计算机科学中的根本瓶颈之所在。软件科学和算法的发展,就看能不能突破这对时空权衡了。呵呵
    何止计算机科学如此,整个宇宙又何尝不是如此呢?最基本的宇宙之谜,还是时间和空间~

     

    展开全文
  • java继承及多态概念PPT

    2019-04-22 19:07:47
    本PPT对java继承的基本概念,语法及应用进行了讲解。在继承的基础上进一步讲解了由继承引出的方法重写及上塑造性,最后引出多态概念以及相关代码实例
  • C#-多态-演示 该代码代表了我在C#中对多态性概念的说明。 等级制 如类图文件Zoo.cd所示 Animal.cs(基类) | | | | ---- Lion.cs(儿童班) | | ---- Monkey.cs(儿童班) | | ---- Zebra.cs(子类)
  • Java多态概念理解(java期中作业)

    千次阅读 2020-11-17 16:35:09
    多态是java继封装、继承后的面向对象的第三大特征,多态是同一个行为具有多个不同表现形式或形态的能力,多态是一个接口,使用不同的实例而执行不同操作。使用多态可以使程序有良好的扩展,并可以对所有类的对象进行...
  • 多态概念

    2016-06-13 22:17:58
    面向对象三大特征: 1.封装: 封装可以隐藏实现细节,使得代码模块化;封装是把过程和数据包围起来...多态的目的则是为了接口重用。也就是说,不论传递过来的究竟是那个类的对象,函数都能够通过同一个接口调用到适应
  • 一 : 多态 1.1 什么是多态 多态: 把子类对象伪装成父类类型 让父类类型指向子类对象 给子类对象起一个父类类型的名字 父类类型的引用=子类类型的对象 1.2 多态对象有那些特点 多态对象: 起了父类类型名字的子类...
  • 封装:封装:就是把事物封装成类,,隐藏事物的属性和方法的实现细节,仅对外公开接口。 继承: 多态
  • Java中的多态概念

    2020-03-01 01:19:13
    文章目录Java中存在多态的前提条件多态中的成员访问特点多态中向上转型和向下转型 Java中存在多态的前提条件 要有继承关系 要有方法重写 要有父类引用指向子类对象 多态中的成员访问特点 成员变量:编译看左边...
  • C# 多态概念

    2012-12-05 15:35:42
    C# 中 多态概念,不同对象对于同一个方法实现不同的效果
  • 我对面向对象中多态概念的理解

    千次阅读 2019-03-08 11:24:48
    我认为可以从两种角度理解多态,它们其实是同一个意思的两种表述形式。 站在调用方的角度来讲:相同的操作,作用于不同类型的对象,可以产生不同的效果。 比如同样的加法操作,作用于整数上,就是数学的相加;...
  • Java多态概念与应用

    千次阅读 多人点赞 2021-03-07 12:33:28
    1.1 多态概念 多态指的是同一个行为具有多个不同表现形式或形态的能力。是不是感觉很抽象,很难理解。没关系,接下来将用一个小demo带你了解多态的概念和优点。 提示:文章写完后,目录可以自动生成,如何生成可参考...
  • 1、讲解和演示虚函数的概念与作用; 2、讲解和演示虚函数与多态在开发中的应用;
  • C++多态的基本概念

    2020-11-08 12:28:49
    多态的基本概念 多态是C++面向对象三大特性之一 多态分为两类 静态多态: 函数重载 和 运算符重载属于静态多态,复用函数名 动态多态: 派生类和虚函数实现运行时多态 静态多态和动态多态区别: 静态多态的函数地址...
  • C++的多态概念

    2015-04-26 15:52:31
    C++中类的继承中有多态性的概念,所谓的多态就是在类里使用虚函数后,用父类作为对象指针,来正确的调用不同子类或父类来作为相应虚函数。虚基类实际就是继承时使用virtual关键字来定义,为的是让在多重继承时遇到...
  • 多态的基本概念 多态:同一种事物表现出来的多种形态。 多态语法格式 格式为:父类类型的引用指向子类类型的对象。如下所示 Person person=new Worker(); 多态的特点 (1)当父类类型的引用指向子类类型的对象时,...
  • Java 多态的特性和概念

    千次阅读 2019-04-25 16:52:51
    多态是同一个行为具有多个不同表现形式或形态的能力。 多态就是同一个接口,使用不同的实例而执行不同操作,如图所示: image 多态性是对象多种表现形式的体现。 现实中,比如我们按下 F1 键这个动作: ...
  • 多态概念总结

    千次阅读 2017-03-17 17:36:02
    一、基本概念 多态:具有多种形式或形态的情形(最初来源于希腊语,在C++中有广泛的含义)。 多态分类图: 静态多态:编译器在编译期间完成的,编译器根据函数实参的类型(可能会进行隐式类型的转换),可推断出要...
  • 多态概念、定义以及实现

    万次阅读 2019-09-26 19:51:38
    多态概念 1. 多态 多态概念:通俗来说,就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同 的状态。 2.举个栗子 比如买票这个行为,当普通人买票时,是全价买票;学生买票时,是半价...
  • 一开始搞不懂多态,现在明白了,特来总结一下 虚基类(虚拟继承) 避免多次基类,避免二义性,保证基类只有一份拷贝 多重继承 为避免二义性的出现,用类域限定符明确指出调用函数所属的基类 虚析构函数 实现多态...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 119,589
精华内容 47,835
关键字:

多态的概念