精华内容
下载资源
问答
  • 1.实现多态的条件是什么? (1).继承的存在(继承是多态的基础,没有继承就没有多态) (2).子类重写父类的方法(多态下调用的是子类重写后的方法) 父类引用变量指向子类对象(向上转型) 2.多态的优点是什么 减少...

    26.多态的总结:多态有哪两种???运行时多态常见哪三种实现方式???运行时多态的前提是什么???多态中成员的访问特点是什么???多态的好处和弊端是什么???向上转型和向下转型的区别???

    学习:第7遍


    1.多态有哪两种???

    第一种:编译时多态
    实现方式:方法重载

    第二种:运行时多态
    直到系统运行时
    才根据实际情况决定实现何种操作
    实现方式:方法重写


    2.运行时多态常见哪三种实现方式???

    方式一:左边父类是普通类
    右边子类是普通类
    存在继承关系

    Father  father =  new Son() ;
    

    方式二:左边父类Animal类是抽象类
    右边子类Cat是普通类
    存在继承关系

    Animal animal = new Cat();
    

    方式三:左边CodeImpl 是接口
    右边Student是实现了接口的普通类
    存在实现关系

    CodeImpl coder = new Student() 
    

    3.运行时多态的前提是什么???

    一:有继承关系
    二:有方法重写
    三:有父类引用指向子类实例


    4.多态中成员的访问特点是什么???

    成员变量:编译看左边,执行看左边。
    成员方法:编译看左边,执行看右边。


    5.多态的好处和弊端是什么???

    多态的好处:提高了程序的扩展性
    具体体现:定义方法,使用父类型作为参数
    将来调用时,调用具体的子类实例

    多态的弊端:不能使用子类的特有功能


    6.向上转型和向下转型的区别???

    向上转型:
    本质是子类转换为父类
    是自动类型转换
    父类引用指向子类实例

    向下转型:
    本质是父类转化为子类
    是强制类型转换
    前提用instanceof判断
    是否可转换为指定子类

    展开全文
  • Python多态两种实现形式

    万次阅读 2020-10-27 18:25:50
    以下是Python伪代码实现Java或C的多态: class A(object): def test(self): print('A test') class B(A): def test(self): print('B test') class C(A): def test(self): print('C t

    说明:仅供学习使用,请勿用于非法用途,若有侵权,请联系博主删除

    作者:zhu6201976

    博客:https://blog.csdn.net/zhu6201976

    一、Python多态

    1.对象多态

    对象多态:在继承体系中,定义时的类型和运行时的类型不一样,此时就构成多态

    以下是Python伪代码实现Java或C的多态:

    class A(object):
        def test(self):
            print('A test')
    
    
    class B(A):
        def test(self):
            print('B test')
    
    
    class C(A):
        def test(self):
            print('C test')
    
    
    def go(a):
        """
        接收A类或其子类实例
        :param a:
        :return:
        """
        a.test()
    
    
    if __name__ == '__main__':
        go(A())
        go(B())
        go(C())

    执行结果:

    由此可见,go函数接收A类或其子类对象,无论是传递A类对象、B类对象、C类对象,方法都可以正常执行, 此时便构成了对象的多态。

    2.类多态

    类多态:指通过@classmethod形式多态地构造对象,而不是使用Python默认的__init__构造器

    需求:实现一套MapReduce流程,用于统计目录下所有文件的总行数,代码如下:

    """
    知识要点:
        1.接口 抽象 继承
        2.生成器
        3.map reduce
        4.多线程
        5.通过@classmethod形式批量创建对象
    """
    import os
    import threading
    
    
    class GenericInputData(object):
        """
        通用输入抽象类 抽象方法由子类实现
        """
        def read(self):
            raise NotImplementedError
    
        @classmethod
        def generate_inputs(cls, config):
            raise NotImplementedError
    
    
    class FileInputData(GenericInputData):
        """
        文件输入类
        """
        def __init__(self, path):
            super().__init__()
            self.path = path
    
        def read(self):
            return open(self.path, 'r', encoding='utf-8').read()
    
        @classmethod
        def generate_inputs(cls, config):
            dir_path = config['dir_path']
            for file_name in os.listdir(dir_path):
                yield cls(os.path.join(dir_path, file_name))
    
    
    class GenericWorker(object):
        """
        通用Worker抽象类 抽象方法由子类实现
        """
        def __init__(self, input_data):
            self.input_data = input_data
            self.result = None
    
        def map(self):
            raise NotImplementedError
    
        def reduce(self, other):
            raise NotImplementedError
    
        @classmethod
        def generate_workers(cls, input_class, config):
            for input_data in input_class.generate_inputs(config):
                yield cls(input_data)
    
    
    class LineCountWorker(GenericWorker):
        """
        统计文件换行符Worker类
        """
        def map(self):
            content = self.input_data.read()
            self.result = content.count('\n')
    
        def reduce(self, other):
            self.result += other.result
    
    
    def execute(workers):
        threads = [threading.Thread(target=w.map) for w in workers]
        for thread in threads:
            thread.start()
            thread.join()
    
        first, rest = workers[0], workers[1:]
        for other in rest:
            first.reduce(other)
    
        return first.result
    
    
    def map_reduce(input_class, worker_class, config):
        gen_workers = worker_class.generate_workers(input_class, config)
        workers = list(gen_workers)
        return execute(workers)
    
    
    if __name__ == '__main__':
        result = map_reduce(FileInputData, LineCountWorker, {'dir_path': 'temp'})
        print(result)
    

    由此可见,在Python中,不仅可以通过__init__构造器创建对象,也可以通过@classmethod形式多态地构建对象。

    展开全文
  • (2)动态多态(覆盖,虚函数实现) 在运行的时候,才确定调用的是哪个函数,动态绑定。运行基类指针指向派生类的对象,并调用派生类的函数。 虚函数实现原理:虚函数表和虚函数指针。 纯虚函数: virtual int fun()...

    (1)静态多态(重载,模板)

    是在编译的时候,就确定调用函数的类型。

    (2)动态多态(覆盖,虚函数实现)

    在运行的时候,才确定调用的是哪个函数,动态绑定。运行基类指针指向派生类的对象,并调用派生类的函数。

    虚函数实现原理:虚函数表和虚函数指针。

    纯虚函数: virtual int fun() = 0;

    多态基础介绍:

    ===============================================================================================

    首先,什么是多态(Polymorphisn)?按字面的意思就是"多种形状"。我手头的书上没有找到一个多态的理论性的概念的描述。

    暂且引用一下 Charlie Calverts的对多态的描述吧——多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作(摘自"Delphi4 编程技术内幕")。

    简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数(Virtual Function) 实现的。

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

    这里有一个初学者经常混淆的概念。覆盖(override)和重载(overload)。

    上面说了,覆盖是指子类重新定义父类的虚函数的做法。而重载,是指允许存在多个同名函数,而这些函数的参数表不同(或许参数个数不同,或许参数类型不同,或许两者都不同)。其实,重载的概念并不属于"面向对象编程",重载的实现是:编译器根据函数不同的参数表,对同名函数的名称做修饰,然后这些同名函数就成了不同的函数(至少对于编译器来说是这样的)。如,有两个同名函数:function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的:int_func、str_func。对于这两个函数的调用,在编译器间就已经确定了,是静态的(记住:是静态)。也就是说,它们的地址在编译期就绑定了(早绑定),因此,重载和多态无关!

    真正和多态相关的是 “覆盖”。当子类重新定义了父类的虚函数后,父类指针根据赋给它的不同的子类指针,动态(记住:是动态!)的调用属于子类的该函数,这样的函数调用在编译期间是无法确定的(调用的子类的虚函数的地址无法给出)。
    因此,这样的函数地址是在运行期绑定的(晚邦定)。结论就是:重载只是一种语言特性,与多态无关,与面向对象也无关!

    那么,多态的作用是什么呢?我们知道,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了——代码重用。

    而多态则是为了实现另一个目的——接口重用!而且现实往往是,要有效重用代码很难,而真正最具有价值的重用是接口重用,因为"接口是公司最有价值的资源。设计接口比用一堆类来实现这个接口更费时间。而且接口需要耗费更昂贵的人力的时间。"

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

    覆盖是指派生类中存在重新定义的函数,其函数名、参数列、返回值类型必须同父类中的相对应被覆盖的函数严格一致,覆盖函数和被覆盖函数只有函数体(花括号中的部分)不同.

    当派生类对象调用子类中该同名函数时会自动调用子类中的覆盖版本,而不是父类中的被覆盖函数版本,这种机制就叫做覆盖。

    下面我们从成员函数的角度来讲述重载和覆盖的区别。

    成员函数被重载的特征有:

    1. 相同的范围(在同一个类中);

    2. 函数名字相同;

    3. 参数不同;

    4. virtual关键字可有可无。

    覆盖的特征有:

    1. 不同的范围(分别位于派生类与基类);

    2. 函数名字相同;

    3. 参数相同;

    4. 基类函数必须有virtual关键字。

    隐藏是指派生类的函数屏蔽了与其同名的基类函数,规则如下:

    1. 如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual关键字,基类的函数将被隐藏(注意别与重载混淆)。

    2. 如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)。

    展开全文
  • 多态实现两种方式

    2010-08-18 17:10:00
    看《C++ Template》一书中才发现使用模板也可以实现多态,所不同的是模板灵活性不如抽象类,但是是静态编译的,因此效率要高。 #include class Shape { public: virtual void draw() const = 0; }...

    看《C++ Template》一书中才发现使用模板也可以实现多态,所不同的是模板灵活性不如抽象类,但是是静态编译的,因此效率要高。

    展开全文
  • C++学习--多态有哪种方式

    千次阅读 2018-06-23 08:14:34
    https://www.cnblogs.com/Allen-rg/p/6927129.htmlC++多态方式:(1)静态多态(重载,模板)是在编译的时候,就确定调用函数的类型。(2)动态多态(覆盖,虚函数实现)在运行的时候,才确定调用的是哪个函数,动态...
  • 以下就是生活中两种多态的实例,**抽象类是模板,接口是功能。 **描述: Door.java 抽象类 package com.dialogd.polymorphic; //抽象类,抽象类是一种模板 public abstract class Door { //开门的...
  • 实现多态两种形式

    千次阅读 2017-06-15 19:03:00
    a.使用父类作为方法形参实现多态 public void play(Pet p){} b.使用父类作为方法返回值实现多态 public Pet getPet(int type){} 转载于:https://www.cnblogs.com/liumeilin/p/7019502.html...
  • 具有多种形态,调用同一个方法会随上下文不同而产生不同的结果,多态静态多态与动态多态两种。 函数承载方式 函数重载是让同一个函数(函数名字是相同的)可以根据参数不同从而实现不同的处理,之所以称之为函数...
  • C#实现多态的几种方式

    千次阅读 2020-02-10 17:48:03
    实现方式跟抽象类一样,不同点: (1)抽象类中的抽象方法不可在本类实现,而虚方法可以实现。 (2)抽象方法必须定义在抽象类中,而虚方法不需要。 (3)抽象类的子类必须实现其抽象方法,而虚方法可以...
  • C++ 多态 以及实现多态的三种方式

    千次阅读 2014-09-02 21:59:06
    3. C++中实现多态方式... 1 4. 细说用函数重载实现多态... 2 5. 细说用模板函数实现多态... 3 6. 小结... 4 7. 细说用虚函数实现多态... 4 7.1. 虚函数是怎么回事...
  • 多态的四种实现

    2017-08-30 10:25:51
    多态分为两种:通用的多态和特定的多态。两者的区别是前者对工作的类型不加限制,允许对不同类型的值执行相同的代码;后者只对有限数量的类型有效,而且对不同类型的值可能要执行不同的代码。  通用的多态又分为...
  • 实现多态两种方式 一、什么是多态? 父类类型的变量指向子类创建的对象,使用该变量调用父类中一个被子类重写的方法,则父类中的方法呈现出不同的行为特征,这就是多态。 简单的来说编译时方法行为表现的是...
  • 在LESS中,通过Mixin的函数多态特性可以降低调用的复杂度,显著提高工作效率,并能大幅减少代码工作量,实现多态的方法有两种,如下。1. 函数调用方式函数定义的方式如下:.tr-td-style(@size:12px;@color) { tr { ...
  • C++ 多态两种形式

    千次阅读 2018-09-19 17:02:26
    1.多态的概念与分类 多态(Polymorphisn)是面向对象程序设计(OOP)的一个重要特征。多态字面意思为多种状态。...静态多态和动态多态的区别其实只是在什么时候将函数实现和函数调用关联起来,是...
  • 虚拟机中多态实现方式 多态的表现形式分为重载和重写。 重载是指同一类中的同名方法...而在虚拟机中,对这两种多态的表现形式有着不同的实现方式。 重载的实现——静态分派 虚拟机中在重载时是通过参数的静态...
  • 两种多态

    2015-04-30 16:12:00
    多态的字面含义:具有多种不同的形态。关键字:编译期多态(就是重载或者模板) 和运行期多态 int getMax( int param1, int param2 );double getMax( double param1, double param2 );这是重载 下面是模板template...
  • 使用多态有什么好处?我们将根据以上五个问题展开激烈的讨论。 什么是多态?   多态,顾名思义指“多种形态”。多态表示不同的对象可以执行相同的动作,但要通过它们自己的实现代码来执行。 例:猪、狗、猫都...
  • 多态及其实现方式

    2017-06-28 17:08:51
    定义:多态就是指不同对象收到相同消息时,会产生不同行为,同一个类在不同的场合下表现出不同的行为特征 作用:把不同的子类对象都当作父类来看,可以屏蔽不同子类对象之间的差异,写出通用的代码,做出通用的编程...
  • 多态实现方式

    千次阅读 2013-11-23 14:25:00
    多态的形式: 覆盖:输入参数一样,但对于不同的派生类不同的实现, 其多态体现在运行阶段,也就是一个父类的指针可以指向不同的派生类对象,调用不同的同名函数。 重载:类的成员函数里,允许多个不同参数的...
  • Java多态实现

    2012-08-29 13:02:56
    Java多态实现
  • 多态分为 编译时多态 和 运行时多态 。 其中 编辑时多态是静态的 , ...而 运行时多态是动态的 ,它是 通过动态绑定来实现的 ,也就是我们所说的多态性(要继承关系 2.子类要重写父类的方法 3.父类引用指向子类) ...
  • **一 : 多态的定义:二 :多态的类别:2.1 静态多态性2.2 动态多态性:三 :多态的几种实现方式: 多态性可以是静态的或动态的。在静态多态性中,函数的响应是在编译时发生的。在动态多态性中,函数的响应是在运行时...
  • 多态两种表现形式

    千次阅读 2018-04-18 15:00:41
    多态的概念:同一个方法名称,执行不同的操作多态两种形式: 重写和重载重写概念:在继承过程中,子类定义了与父类中名称相同,参数相同,返回值相同的方法称为重写重写时,子类不能比父类的访问权限更严格重写的...
  • 多态两种特征。

    2014-06-14 01:03:26
    多态1:(子类功能实现) 1、继承 2、子类对象赋值给父的引用 Person p=new Student(); 里氏替换原则 3、一定重写父的方法 4、一定用父引用调用的方法,那么执行时子类的方法实现,否则调用的方法一定是父自己...
  • java中提供了哪两种多态的机制

    千次阅读 2015-01-21 15:16:14
    java中提供了哪两种多态的机制 编译时多态和运行时多态。编译时多态是通过方法的重载实现的,运行时多态是通过方法的覆盖(子类覆盖父类方法)实现的。 注:函数不能以返回值来区分的,虽然两个函数有着不同的返回值...
  • 静态多态和动态多态的区别其实只是在什么时候将函数实现和函数调用关联起来,是在编译时期还是运行时期,即函数地址是早绑定还是晚绑定的。静态多态是指在编译期间就可以确定函数的调用地址,并生产代码,这就是静态...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 147,019
精华内容 58,807
关键字:

多态有哪两种实现方式