精华内容
下载资源
问答
  • 8.5.3 多态性 多态性是面向对象技术中最灵活的特性,主要是增强项目的可扩展性,... 在这里把多态性分为两方面来进行介绍,对象类型的多态和对象方法的多态。 为了方便后续的讲解,首先给出一个继承结构的示例。 ...

    8.5.3 多态性          多态性是面向对象技术中最灵活的特性,主要是增强项目的可扩展性,提高代码的可维护性。          多态性依赖继承特性,可以把多态理解为继承性的扩展或者深入。          在这里把多态性分为两方面来进行介绍,对象类型的多态和对象方法的多态。          为了方便后续的讲解,首先给出一个继承结构的示例。                    //文件名:SuperClass.java                    public class SuperClass{                             public void test(){                                      System.out.println(“SuperClass”);                             }                    }                    // 文件名:SubbClass1.java                    public class SubbClass1 extends SuperClass{                             public void test(){                                      System.out.println(“SubbClass1”);                             }                    }                    // 文件名:SubbClass2.java                    public class SubbClass2 extends SuperClass{                             public void test(){                                      System.out.println(“SubbClass2”);                             }                    }          在该示例代码中,SubbClass1和SubbClass2是SuperClass的子类,并且在子类的内部都覆盖父类中的test方法。由于这三个类中都书写构造方法,则按照默认构造方法的约定,每个类中都会被自动添加一个默认的构造方法。 8.5.3.1 对象类型的多态          对象类型的多态是指声明对象的类型不是对象的真正类型,而对象的真正类型由创建对象时调用的构造方法进行决定。例外,按照继承性的说明,子类的对象也是父类类型的对象,可以进行直接赋值。          例如如下代码:                    SuperClass sc = new SubbClass1();          这里声明了一个SuperClass类型的对象sc,然后使用SuperClass的子类SubbClass1的构造方法进行创建,因为子类类型的对象也是父类类型的对象,所以创建出来的对象可以直接赋值给父类类型的对象sc。除了对象的赋值以外,另外一个更重要的知识是sc对象虽然使用SuperClass声明的类型,但是内部存储的却是SubbClass1类型的对象。这个可以Java语言的中instanceof运算符进行判断。          instanceof是一个运算符,其作用是判断一个对象是否是某个类类型的对象,如果成立则表达式的值为true,否则为false。语法格式如下:                    对象名 instanceof 类名          需要注意的是:这里的类名必须和声明对象时的类之间存储继承关系,否则将出现语法错误。          测试类型的代码如下:                    /** * 测试对象类型的多态 */ public class TestObjectType {          public static void main(String[] args) {                                       SuperClass sc = new SubbClass1();                                       boolean b = sc instanceof SuperClass;                                       boolean b1 = sc instanceof SubbClass1;                                       System.out.println(b);                                       System.out.println(b1);                             } }          该测试程序的输出结果是:                    true                    true          由程序运行结果可以看出,sc既是SuperClass类型的对象,也是SubbClass1类型的对象,而SubbClass1的类型被隐藏起来了,这就是对象的多态。其实sc对象不仅仅在类型上是SubbClass1类型的,其存储的内容也是SubbClass1的内容,具体参看后面介绍的对象方法的多态。          对象类型的多态有很多的用途,极大的方便了对象的存储和传递,使代码很方便的进行扩展,对于已有代码不产生影响。下面介绍两个基本的使用。 1.         对象的存储 在存储一系列不同子类的对象时,可以使用父类的结构来进行声明,这样可以方便数据的存储,例如需要存储多个SubbClass1和SubbClass2的对象时,则可以声明一个SuperClass类型的数组进行存储,示例代码如下:          SuperClass sc[] = new SuperClass[3];          sc[0] = new SubbClass1();          sc[1] = new SubbClass2();          sc[2] = new SubbClass1(); 则这里的数组sc,可以存储各个类型子类的对象,而数组中每个元素的值都是存储的对应子类的对象,而只是在名义上的类型(语法上的类型)是SuperClass类型的,这样将方便程序的控制,当增加新的子类类型时,已有的代码不需要进行改造就可以自动适应新的子类的结构。 例如新增了一个SuperClass的子类SubbClass3,则该数组的代码可以修改成如下:          SuperClass sc[] = new SuperClass[3];          sc[0] = new SubbClass1();          sc[1] = new SubbClass2();          sc[2] = new SubbClass3(); 其它的代码都需要进行修改,就可以适应新的结构,这是多态性最主要的用途。 2.         对象的传递 在方法的传入参数传递,以及返回值处理方面都从对象类型的多态中受益。在向方法中传入参数时,如果该方法需要处理各个子类的对象,则只需要书写一个接受父类类型对象的方法即可。例如:          public void testObjectTypeMethod(SuperClass sc){} 则该在调用该方法时,可以传入SuperClass的对象,也可以传入其子类的对象,如果传入的是子类的对象,则子类对象中的内容不会丢失。例如调用的示例代码如下:          SuperClass sc = new SuperClass();          SubbClass1 sc1 = new SubbClass1();          SubbClass2 sc2 = new SubbClass2();          testObjectTypeMethod(sc); testObjectTypeMethod(sc1); testObjectTypeMethod(sc2); 这里说明的只是调用时的语法结构,这样的特性将使我们只需要书写一个方法,就可以处理所有子类的对象,简化代码的书写,降低代码的重复,从而降低维护的难度。 另外,方法的返回值也可以利用到该特性,例如如下方法:          public SuperClass testObjectTypeMethod2(){} 则在该方法的内部,既可以返回SuperClass类型的对象,也可以返回其子类的对象,也能简化代码的书写,便于代码的阅读和维护。          关于对象类型的多态,就简单的说明这么多,具体在项目中如何进行使用,还需要一定的技巧和方法。 8.5.3.2 对象方法的多态          对象方法的多态基于方法的覆盖,也就是该对象调用的方法具体是子类的方法还是父类的方法,由创建对象时使用的构造方法决定,而不是由声明对象时声明的类型决定。          示例代码如下:                    /**                   * 测试对象方法的多态 */ public class TestObjectMethod {                             public static void main(String[] args) {                                       SuperClass sc = new SuperClass();                                       SubbClass1 sc1 = new SubbClass1();                                       SubbClass2 sc2 = new SubbClass2();                                      SuperClass sc3 = new SubbClass1();                                       testObjectTypeMethod(sc);                                       testObjectTypeMethod(sc1);                                       testObjectTypeMethod(sc2);                                      testObjectTypeMethod(sc3);                             }                                                        public static void testObjectTypeMethod(SuperClass sc){                                       sc.test(); //调用被覆盖的方法                             } }          该代码的执行结果如下:                    SuperClass SubbClass1 SubbClass2 SubbClass1          则从代码的执行结果看,虽然testObjectTypeMethod方法接收的是SuperClass类型的对象,但是传入子类对象时,子类对象的内容没有丢失,所以在调用test方法时,还是调用的对应对象中对应的test方法。          这样就在功能上实现了对象的传递,从而保留了对象的内容,极大的方便了代码的扩展性。          但是,由于Java在执行程序时,在程序运行的过程中,需要判断对象调用的具体是父类的方法还是子类的方法,所以程序的执行速度会稍微有所降低。

    展开全文
  • 多态性

    2016-05-09 10:46:55
    多态性分为如下两种。 (1)编译时的多态性。编译时的多态性是通过重载来实现的。系统在编译时,根据传递 的参数、返回的类型等信息决定实现何种操作。 (2)运行时的多态性。运行时的多态性就是指直到系统运行时
    6.1.4 多态性
    多态性是面向对象技术的一个重要概念。同一操作作用于不同的对象,可以有不同的解释,
    产生不同的执行结果,这就是多态性。多态性通常通过派生类重载基类中的同名函数来实现。
    多态性分为如下两种。
    (1)编译时的多态性。编译时的多态性是通过重载来实现的。系统在编译时,根据传递
    的参数、返回的类型等信息决定实现何种操作。
    (2)运行时的多态性。运行时的多态性就是指直到系统运行时,才根据实际情况决定实
    现何种操作。
    编译时的多态性提供了运行速度快的特点,而运行时的多态性则带来了高度灵活和抽象
    的特点。
    多态性大致有以下 3 种实现方式。
    (1)通过接口实现多态性。接口描述类需要实现的操作、属性和事件,以及每个操作需
    要接收和返回的参数类型,但将这些操作的特定实现留给实现接口的类去完成。多个类可实
    现相同的“接口”,而单个类可以实现一个或多个接口。这样实现某接口的类都有此接口定义
    的操作的不同实现方式。
    (2)通过继承实现多态性。多个类可以从单个基类“继承”,子类不仅接收基类的所有方
    法、属性和事件,还可以重写基类的操作以提供不同的实现。继承实现的多态性使成员函数
    根据收到该调用的对象的类型产生不同的动作,类的使用者可以处理普遍性而让执行环境处
    理特殊性,提高了系统的可扩展性。
    (3)通过抽象类实现的多态性。抽象类为多态的实现提供了极大的灵活性,因为它同时
    提供继承和接口的元素。抽象类本身不能实例化,必须被继承。抽象类的部分或全部成员可
    能未实现,该实现由继承类提供。已实现的成员仍可被重写,并且继承类仍可以实现附加接
    口或其他功能。
    展开全文
  • c# 多态性

    2019-07-12 17:29:52
    多态性分为两种,一种是编译时的多态性,一种是运行时的多态性。 编译时的多态性:编译时的多态性是通过重载来实现的。对于非虚的成员来说,系统在编译时,根据传递的参数、返回的类型等信息决定实现何种操作。 ...

    首先理解一下什么叫多态。同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果,这就是多态性

    多态性通过派生类覆写基类中的虚函数型方法来实现。

     

    多态性分为两种,一种是编译时的多态性,一种是运行时的多态性

    编译时的多态性:编译时的多态性是通过重载来实现的。对于非虚的成员来说,系统在编译时,根据传递的参数、返回的类型等信息决定实现何种操作。

    运行时的多态性:运行时的多态性就是指直到系统运行时,才根据实际情况决定实现何种操作。C#中运行时的多态性是通过覆写虚成员实现。

     

    下面我们来分别说明一下多态中涉及到的四个概念:重载,覆写,虚方法和抽象方法。

    重载和覆写的区别:

    重载

    类中定义的方法的不同版本

             public int Calculate(int x, int y)

             public double Calculate(double x, double y)

    特点(两必须一可以)

             方法名必须相同

             参数列表必须不相同

             返回值类型可以不相同

    覆写

             子类中为满足自己的需要来重复定义某个方法的不同实现。

             通过使用override关键字来实现覆写。

             只有虚方法和抽象方法才能被覆写。

             要求(三相同)

                       相同的方法名称

                       相同的参数列表

                       相同的返回值类型

    最后再来介绍一下虚方法和抽象方法

    虚方法:

    声明使用virtual关键字。

    调用虚方法,运行时将确定调用对象是什么类的实例,并调用适当的覆写的方法。

    虚方法可以有实现体。

    抽象方法:

    必须被派生类覆写的方法。

    可以看成是没有实现体的虚方法。

    如果类中包含抽象方法,那么类就必须定义为抽象类,不论是否还包含其他一般方法。

    注意:

    昨天突然发现c#,和c++俩种语言在多态性的 实现机制 上面的细微差别。     如果是C++,在基类的构造函数里面调用虚函数的话,会调用本类的不会调用派生类的,原因是基类构造的时候,虚表还没有被派生类继承和修改。

        但如果是C#,那就不同了,在基类的构造函数里面照样调用派生类的。不知道有谁知道c#它的这种底层机制是怎样的? -------是这样的,C++会先初始化基类,然后逐级初始化派生类型。C#则是一开始就把对象创建好了,然后逐个调用构造函数。本质区别在于C++的 构造函数的任务是初始化,C#则不然,C#的类型的任何字段不必初始化,均有默认值,所以C#在调用构造函数之前就已经将对象初始化完毕了。

    通过继承,一个类可以用作多种类型:可以用作它自己的类型、任何基类型,或者在实现接口时用作任何接口类型。这称为多态性。C#中的每种类型都是多态的。类型可用作它们自己的类型或用作Object实例,因为任何类型都自动将Object当作基类型。         多态性不 仅对派生类很重要,对基类也很重要。任何情况下,使用基类实际上都可能是在使用已强制转换为基类类型的派生类对象。基类的设计者可以预测到其基类中可能会 在派生类中发生更改的方面。例如,表示汽车的基类可能包含这样的行为:当考虑的汽车为小型货车或敞篷汽车时,这些行为将会改变。基类可以将这些类成员标记 为虚拟的,从而允许表示敞篷汽车和小型货车的派生类重写该行为。

    转自:http://www.cnblogs.com/sharmy/archive/2008/05/20/1203433.html

    转载于:https://www.cnblogs.com/VicHuang/archive/2012/09/02/2667774.html

    展开全文
  • java多态性

    2019-05-06 10:05:26
    多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务,那么运行时的多态性可以解释为:当A 系统访问 B 系统提供的服务时,B 系统有多种提供服务的方式,但一切对 A 系统来说都是...

    多态性   

        多态性: 指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务,那么运行时的多态性可以解释为:当A 系统访问 B 系统提供的服务时,B 系统有多种提供服务的方式,但一切对 A 系统来说都是透明的。方法重载(overload)实现的是编译时的多态性(也称为前绑定),而方法重写(override)实现的是运行时的多态性(也称为后绑定)。运行时的多态是面向对象最精髓的东西,要实现多态需要做两件事:1. 方法重写(子类继承父类并重写父类中已有的或抽象的方法);2. 对象造型(用父类型的引用引用子类型对象,这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为)。

     

    Java的引用有两种:

    1. 编译时类型:由声明时该变量的类型决定。
    2. 运行时类型:由运行时实际赋值给该变量的类型决定。

     

    多态就是编译时的类型和运行时的类型不一致。

     

     

     

     

     

    展开全文
  • 初探多态性

    2016-12-24 22:52:23
    多态性分为编译时多态性和运行时多态性。 编译时多态性: 一个源程序经过编译、连接,成为可执行程序的过程是把可执行代码连编到一起的过程。其中,在运行之前就完成的联编称为静态连编,即编译时多态性。 优点是...
  • 多态性Polymorphism

    2015-09-26 21:09:00
    一....2.从系统实现的角度看,多态性分为两类: 静态多态性和动态多态性。以前学过的函数重载和运算符重载实现的多态性属于静态多态性,动态多态性是通过虚函数(virtual function)实现的。 3.静...
  • 多态与多态性

    2019-01-09 21:02:00
    多态性是指在不考虑实例类型的情况下使用实例,多态性分为静态多态性和动态多态性 静态多态性:如任何类型都可以用运算符+进行运算 动态多态性:如下 class Ainmal: def eat(self): print('吃吃吃')class Pig: ...
  • C#中的多态性

    2019-10-02 01:09:18
    多态性分为两种,一种是编译时的多态性,一种是运行时的多态性。 编译时的多态性:编译时的多态性是通过重载来实现的。对于非虚的成员来说,系统在编译时,根据传递的参数、返回的类型等信息决定实现何种操作。 ...
  • 多态性与虚函数

    2020-02-08 10:39:41
    在C++程序设计中,多态性(polymorphism)是指具有不同功能的函数可以用同一个...从系统实现的角度看,多态性分为两类:静态多态性和动态多态性。函数重载和运算符重载实现的多态性属于静态多态性,在程序编译时系统就...
  • 面向对象——多态性

    2019-09-30 08:41:56
    多态性:指在不考虑实例类型的情况下使用实例,多态性分为静态多态性和动态多态性 静态多态性:如任何类型都可以用运算符+进行运算 动态多态性:通过定义一个统一的接口来使用 好处 增加程序的灵活性:...
  • java的多态性

    2016-04-25 21:54:17
    java中多态性分为动态多态性和静态多态性。静态多态性就是指方法的重载,是一个类的行为。动态多态性是指方法的重写,即多态是指在有继承关系的两个或两个以上的类的行为。下面是一个重写的小Demopublic class ...
  • C++ 的多态性

    2018-07-06 13:53:26
    C++ 的多态性分为类的多态性和函数的多态性类的多态性---通过虚函数实现1、如果基类中的函数f()没有virtual,在派生类中重写此函数,用派生类的指针 引用 a,去初始化基类的引用或指针b时,b 指向的函数依然是基类的...
  • C++:多态性

    2013-10-24 14:38:02
    从系统的角度,多态性分为两类:静态多态性和动态多态性。静态多态性是通过函数重载实现的,运算符的重载是函数重载的特殊形式,在程序编译时就能决定调用的是那个函数,因此静态多态性又称为编译时的多态性。动态多...
  • C++的多态性

    2017-11-20 16:43:59
    多态性分为:编译期多态(静态多态)和运行时多态(动态动态)。编译时多态编译期多态,正如其名,就是在编译期确定的一种多态性。这个在C++中主要体现在函数模板,这里需要注意的是函数重载和多态无关。// 例1:...
  • C# 多态性

    2010-09-07 16:16:00
    C#多态性分为两种,一种是编译时的多态性,一种是运行时的多态性。 ◆编译时的多态性:编译时的多态性是通过重载来实现的。对于非虚的成员来说,系统在编译时,根据传递的参数、返回的类型等信息决定实现...
  • 多态性是指在不考虑实例类型的情况下使用实例,多态性分为静态多态性和动态多态性 静态多态性:如任何类型都可以用运算符+进行运算 动态多态性:如下 import abc class Animals(metaclass=abc.ABCMeta): @...
  • c# 多态性

    2009-05-26 09:35:00
     多态性分为两种,一种是编译时的多态性,一种是运行时的多态性。编译时的多态性:编译时的多态性是通过重载来实现的。对于非虚的成员来说,系统在编译时,根据传递的参数、返回的类型等信息决定实现何种操作。运行...
  • 多态性的概念

    2015-07-10 17:24:00
    多态性分为编译时的多态性和运行时的多态性。 静态联编是指联编工作出现在程序的编译连接阶段。静态联编在程序编译阶段就知道调用函数的全部信息。其优点是速度快、效率高,缺点是缺乏灵活性。静态联编支持的多...
  • [Python3]多态性

    2018-08-18 10:46:14
    多态性是指在不考虑实例类型的情况下使用实例,多态性分为静态多态性和动态多态性 静态多态性:如任何类型都可以用运算符+进行运算 动态多态性:调用方法的时候 # 鸭子类型 Python崇尚鸭子类型,即‘如果看起来像...
  • 6.1多态性和虚函数

    2018-12-24 20:40:16
    多态性分为两类: 静态多态性(编译时多态性)和动态多态性(运行时多态性) 1.静态多态性很简单,是通过函数的重载实现的,如前面所说:函数重载、运算符重载的实现都是 它要求在程序编译时就知道调用函数的全部...

空空如也

空空如也

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

多态性分为