深入Java核心 Java中多态的实现机制
多态性是Java面向对象的一个重要机制,本文将向您详细介绍Java语言中多态性的实现原理和方法,通过多态一点带出更多Java面向对象有趣而实用的知识。
多态性是面向对象程序设计代码重用的一个重要机制,我们曾不只一次的提到Java多态性。在Java运行时多态性:继承和接口的实现一文中,我们曾详细介绍了Java实现运行时多态性的动态方法调度;今天我们再次深入Java核心,一起学习Java中多态性的实现。
“polymorphism(多态)”一词来自希腊语,意为“多种形式”。多数Java程序员把多态看作对象的一种能力,使其能调用正确的方法版本。尽管如此,这种面向实现的观点导致了多态的神奇功能,胜于仅仅把多态看成纯粹的概念。
Java中的多态总是子类型的多态。几乎是机械式产生了一些多态的行为,使我们不去考虑其中涉及的类型问题。本文研究了一种面向类型的对象观点,分析了如何将对象能够表现的行为和对象即将表现的行为分离开来。抛开Java中的多态都是来自继承的概念,我们仍然可以感到,Java中的接口是一组没有公共代码的对象共享实现。
多态的分类
多态在面向对象语言中是个很普遍的概念.虽然我们经常把多态混为一谈,但实际上有四种不同类型的多态。在开始正式的子类型多态的细节讨论前,然我们先来看看普通面向对象中的多态。
Luca Cardelli和Peter Wegner("On Understanding Types, Data Abstraction, and Polymorphism"一文的作者,文章参考资源链接)把多态分为两大类----特定的和通用的----四小类:强制的,重载的,参数的和包含的。他们的结构如下:
在这样一个体系中,多态表现出多种形式的能力。通用多态引用有相同结构类型的大量对象,他们有着共同的特征。特定的多态涉及的是小部分没有相同特征的对象。四种多态可做以下描述:
◆强制的:一种隐式做类型转换的方法。
◆重载的:将一个标志符用作多个意义。
◆参数的:为不同类型的参数提供相同的操作。
◆包含的:类包含关系的抽象操作。
我将在讲述子类型多态前简单介绍一下这几种多态。
强制的多态
强制多态隐式的将参数按某种方法,转换成编译器认为正确的类型以避免错误。在以下的表达式中,编译器必须决定二元运算符‘+’所应做的工作:
2.0 + 2.0
2.0 + 2
2.0 + "2"
第一个表达式将两个double的操作数相加;Java中特别声明了这种用法。
第二个表达式将double型和int相加。Java中没有明确定义这种运算。不过,编译器隐式的将第二个操作数转换为double型,并作double型的加法。做对程序员来说十分方便,否则将会抛出一个编译错误,或者强制程序员显式的将 int转换为double。
第三个表达式将double与一个String相加。Java中同样没有定义这样的操作。所以,编译器将 double转换成String类型,并将他们做串联。
强制多态也会发生在方法调用中。假设类Derived继承了类Base,类C 有一个方法,原型为m(Base),在下面的代码中,编译器隐式的将Derived类的对象derived转化为Base 类的对象。这种隐式的转换使 m(Base)方法使用所有能转换成Base类的所有参数。
1. C c = new C();
2.
3.Derived derived = new Derived();
4.
5. c.m( derived );
并且,隐式的强制转换,可以避免类型转换的麻烦,减少编译错误。当然,编译器仍然会优先验证符合定义的对象类型。
重载的多态
重载允许用相同的运算符或方法,去表示截然不同的意义。‘+’在上面的程序中有两个意思:两个double型的数相加;两个串相连。另外还有整型相加,长整型,等等。这些运算符的重载,依赖于编译器根据上下文做出的选择。以往的编译器会把操作数隐式转换为完全符合操作符的类型。虽然Java明确支持重载,但不支持用户定义的操作符重载。
Java支持用户定义的函数重载。一个类中可以有相同名字的方法,这些方法可以有不同的意义。这些重载的方法中,必须满足参数数目不同,相同位置上的参数类型不同。这些不同可以帮助编译器区分不同版本的方法。
编译器以这种唯一表示的特征来表示不同的方法,比用名字表示更为有效。据此,所有的多态行为都能编译通过。
强制和重载的多态都被分类为特定的多态,因为这些多态都是在特定的意义上的。这些被划入多态的特性给程序员带来了很大的方便。强制多态排除了麻烦的类型和编译错误。重载多态像一块糖,允许程序员用相同的名字表示不同的方法,很方便。
参数的多态
参数多态允许把许多类型抽象成单一的表示。例如,List 抽象类中,描述了一组具有同样特征的对象,提供了一个通用的模板。你可以通过指定一种类型以重用这个抽象类。这些参数可以是任何用户定义的类型,大量的用户可以使用这个抽象类,因此参数多态毫无疑问的成为最强大的多态。
乍一看,上面抽象类好像是java.util.List的功能。然而,Java实际上并不支持真正的安全类型风格的参数多态,这也是java.util.List和java.util的其他集合类是用原始的 https://www.doczj.com/doc/4e18912274.html,ng.Object写的原因(参考我的文章"A Primordial Interface?" 以获得更多细节)。Java的单根继承方式解决了部分问题,但没有发挥出参数多态的全部功能。Eric Allen有一篇精彩的文章“Behold the Power of Parametric Polymorphism”,描述了Java 通用类型的需求,并建议给Sun的Java规格需求#000014号文档"Add Generic Types to the Java Programming Language."(参考资源链接)
包含的多态
包含多态通过值的类型和集合的包含关系实现了多态的行为.在包括Java在内的众多面向对象语言中,包含关系是子类型的。所以,Java的包含多态是子类型的多态。
在早期,Java开发者们所提及的多态就特指子类型的多态。通过一种面向类型的观点,我们可以看到子类型多态的强大功能。以下的文章中我们将仔细探讨这个问题。为简明起见,下文中的多态均指包含多态。
面向类型观点
图1的UML类图给出了类和类型的简单继承关系,以便于解释多态机制。模型中包含5种类型,4个类和一个接口。虽然UML中称为类图,我把它看成类型图。如"Thanks Type and Gentle Class," 一文中所述,每个类和接口都是一种用户定义的类型。按独立实现的观点(如面向类型的观点),下图中的每个矩形代表一种类型。从实现方法看,四种类型运用了类的结构,一种运用了接口的结构。
图1:示范代码的UML类图
以下的代码实现了每个用户定义的数据类型,我把实现写得很简单。
用这样的类型声明和类的定义,图2从概念的观点描述了Java指令。
Derived2 derived2 = new Derived2();
图2 :Derived2 对象上的引用
上文中声明了 derived2这个对象,它是Derived2类的。图2种的最顶层把Derived2引用描述成一个集合的窗口,虽然其下的Derived2对象是可见的。这里为每个Derived2类型的操作留了一个孔。Derived2对象的每个操作都去映射适当的代码,按照上面的代码所描述的那样。例如,Derived2对象映射了在Derived中定义的m1()方法。而且还重载了Base类的m1()方法。一个Derived2的引用变量无权访问 Base类中被重载的m1()方法。但这并不意味着不可以用super.m1()的方法调用去使用这个方法。关系到derived2这个引用的变量,这个代码是不合适的。Derived2的其他的操作映射同样表明了每种类型操作的代码执行。
既然你有一个Derived2对象,可以用任何一个Derived2类型的变量去引用它。如图1所示,Derived, Base和IType都是Derived2的基类。所以,Base类的引用是很有用的。图3描述了以下语句的概念观点。
Base base = derived2;
图3:Base类引用附于Derived2对象之上
虽然Base类的引用不用再访问m3()和m4(),但是却不会改变它Derived2对象的任何特征及操作映射。无论是变量derived2还是 base,其调用m1()或m2(String)所执行的代码都是一样的。
两个引用之所以调用同一个行为,是因为Derived2对象并不知道去调用哪个方法。对象只知道什么时候调用,它随着继承实现的顺序去执行。这样的顺序决定了Derived2对象调用Derived里的m1()方法,并调用Derived2 里的m2(String)方法。这种结果取决于对象本身的类型,而不是引用的类型。
尽管如此,但不意味着你用derived2和 base引用的效果是完全一样的。如图3所示,Base的引用只能看到Base类型拥有的操作。所以,虽然Derived2有对方法m3()和m4()的映射,但是变量base不能访问这些方法。
运行期的Derived2对象保持了接受m3()和m4()方法的能力。类型的限制使 Base的引用不能在编译期调用这些方法。编译期的类型检查像一套铠甲,保证了运行期对象只能和正确的操作进行相互作用。换句话说,类型定义了对象间相互作用的边界。
多态的依附性
类型的一致性是多态的核心。对象上的每一个引用,静态的类型检查器都要确认这样的依附和其对象的层次是一致的。当一个引用成功的依附于另一个不同的对象时,有趣的多态现象就产生了。(严格的说,对象类型是指类的定义。)你也可以把几个不同的引用依附于同一个对象。在开始更有趣的场景前,我们先来看一下下面的情况为什么不会产生多态。
多个引用依附于一个对象
图2和图3描述的例子是把两个及两个以上的引用依附于一个对象。虽然Derived2
对象在被依附之后仍保持了变量的类型,但是,图3中的Base类型的引用依附之后,其功能减少了。结论很明显:把一个基类的引用依附于派生类的对象之上会减少其能力。
一个开发这怎么会选择减少对象能力的方案呢?这种选择是间接的。假设有一个名为ref的引用依附于一个包含如下方法的类的对象:
用一个Derived2的参数调用poly(Base)是符合参数类型检查的:
方法调用把一个本地Base类型的变量依附在一个引入的对象上。所以,虽然这个方法只接受Base类型的参数,但Derived2对象仍是允许的。开发这就不必选择丢失功能的方案。从人眼在通过Derived2对象时所看到的情况,Base 类型引用的依附导致了功能的丧失。但从执行的观点看,每一个传入poly1(Base)的参数都认为是Base的对象。执行机并不在乎有多个引用指向同一个对象,它只注重把指向另一个对象的引用传给方法。这些对象的类型不一致并不是主要问题。执行器只关心给运行时的对象找到适当的实现。面向类型的观点展示了多态的巨大能力。
附于多个对象的引用
让我们来看一下发生在poly1(Base)中的多态行为。下面的代码创建了三个对象,并通过引用传给poly1(Base):
poly1(Base)的实现代码是调用传进来的参数的m1()方法。图3和图4展示了把三个类的对象传给方法时,面向类型的所使用的体系结构。
图4:将Base引用指向Derived类,以及Base对象
请注意每个图中方法m1()的映射。图3中,m1()调用了Derived类的代码;上面代码中的注释标明了ploy1(Base)调用 Derived.m1()。图4中Derived对象调用的仍然是Derived类的m1()方法。最后,图4中,Base对象调用的m1()是Base 类中定义的代码。
多态的魅力何在?再来看一下poly1(Base)的代码,它可以接受任何属于Base类范畴的参数。然而,当他收到一个Derived2的对象时,它实际上却调用了Derived版本的方法。当你根据Base类派生出其他类时,如 Derived,Derived2,poly1(Base)都可以接受这些参数,并作出选择调用合适的方法。多态允许你在完成poly1(Base)后扩展它的用途。
这看起来当然很神奇。基本的理解展示了多态的内部工作原理。在面向类型的观点中,底层的对象所实现的代码是非实质性的。重要的是,类型检查器会在编译期间为每个引用选择合适的代码以实现其方法。多态使开发者运用面向类型的观点,不考虑实现的细节。这样有助于把类型和实现分离(实际用处是把接口和实现分离)。
对象接口
多态依赖于类型和实现的分离,多用来把接口和实现分离。但下面的观点好像把Java 的关键字 interface搞得很糊涂。
更为重要的使开发者们怎样理解短语“the interface to an object",典型地,根据上下文,这个短语的意思是指一切对象类中所定义的方法,至一切对象公开的方法。这种倾向于以实现为中心的观点较之于面向类型的观点来说,使我们更加注重于对象在运行期的能力。图3中,引用面板的对象表面被标志成"Derived2 Object"。这个面板上列出了Derived2对象的所有可用的方法。但是要理解多态,我们必须从实现这一层次上解放出来,并注意面向类型的透视图中被标为"Base Reference"的面板。在这一层意思上,引用变量的类型指明了一个对象的表面。这只是一个表面,不是接口。在类型一致的原则下,我们可以用面向类型的观点,为一个对象依附多个引用。对interface to an object这个短语的理解没有确定的理解。
在类型概念中,the interface to an object refers 引用了面向类型观点的最大可能----如图2的情形。把一个基类的引用指向相同的对象缩小了这样的观点----如图3所示。类型概念能使人获得把对象间的相互作用同实现细节分离的要领。相对于一个对象的接口,面向类型的观点更鼓励人们去使用一个对象的引用。引用类型规定了对象间的相互作用。当你考虑一个对象能做什么的时候,只需搞明白他的类型,而不需要去考虑他的实现细节。
Java接口
以上所谈到的多态行为用到了类的继承关系所建立起来的子类型关系。Java接口同样支持用户定义的类型,相对地,Java的接口机制启动了建立在类型层次结构上的多态行为。假设一个名为ref的引用变量,并使其指向一个包含一下方法的类对象:
为了弄明白poly2(IType)中的多态,以下的代码从不同的类创建两个对象,并分别把他们传给 poly2(IType):
上面的代码类似于关于poly1(Base)中的多态的讨论。poly2(IType)的实现代码是调
用每个对象的本地版本的m3()方法。如同以前,代码的注释表明了每次调用所返回的CString类型的结果。图5表明了两次调用poly2(IType)的概念结构:
图5:指向Derived2和Separate对象的IType引用
方法poly1(Base)和poly2(IType)中所表现的多态行为的相似之处可以从透视图中直接看出来。把我们在实现在一层上的理解再提高一层,就可以看到这两段代码的技巧。基类的引用指向了作为参数传进的类,并且按照类型的限制调用对象的方法。引用既不知道也不关心执行哪一段代码。编译期间的子类型关系检查保证了通过的对象有能力在被调用的时候选择合适的实现代码。
然而,他们在实现层上有一个重要的差别。在 poly1(Base)的例子中(图3和图4),Base-Derived-Derived2的类继承结构为子类型关系的建立提供了条件,并决定了方法去
调用哪段代码。在poly2(IType)的例子中(如图5),则是完全不同的动态发生的。Derived2和Separate不共享任何实现的层次,但是他们还是通过IType的引用展示了多态的行为。
这样的多态行为使Java的接口的功能的重大意义显得很明显。图1中的UML类图说明了Derived是Base和IType的子类型。通过完全脱离实现细节的类型的定义方法,Java实现了多类型继承,并且不存在Java所禁止的多继承所带来的烦人的问题。完全脱离实现层次的类可以按照Java接口实现分组。在图1中,接口IType和Derived,Separate以及这类型的其他子类型应该划为一组。
按照这种完全不同于实现层次的分类方法,Java的接口机制是多态变得很方便,哪怕不存在任何共享的实现或者复写的方法。如图5所示,一个IType的引用,用多态的方法访问到了Derived2和Separate对象的m3()方法。
再次探讨对象的接口
注意图5中的Derived2和Separate对象的对m1()的映射方法。如前所述,每一个对象的接口都包含方法m1()。但却没有办法用这两个对象使方法m1()表现出多态的行为。每一个对象占有一个m1()方法是不够的。必须存在一个可以操作 m1()方法的类型,通过这个类型可以看到对象。这些对象似乎是共享了m1()方法,但在没有共同基类的条件下,多态是不可能的。通过对象的接口来看多态,会把这个概念搞混。
结论
从全文所述的面向对象多态所建立起来的子类型多态,你可以清楚地认识到这种面向类型的观点。如果你想理解子类型多态的思想,就应该把注意力从实现的细节转移到类型的上。类型把对象分成组,并且管理着这些对象的接口。类型的继承层次结构决定了实现多态所需的类型关系。
有趣的是,实现的细节并不影响子类型多态的层次结构。类型决定了对象调用什么方法,而实现则决定了对象怎么执行这个方法。也就是说,类型表明了责任,而负责实施的则是具体的实现。将实现和类型分离后,我们好像看到了这两个部分在一起跳舞,类型决定了他的舞伴和舞蹈的名字,而实现则是舞蹈动作的设计师。
共交力系及一图多态小专 例题1:如图所示,用完全相同的轻质弹簧1、2、3将两个相同的小球连接并懋挂,小球静止时,弹簧3水平,弹簧1与竖直方向的夹角θ=30°,弹簧1的弹力大小为F ,则( B ) A. 弹簧3的弹力大小为2F B. 弹簧3的弹力大小为2 F C. 每个小球重力大小为23F D. 每个小球重力大小为3F 解决方法1:整体隔离法 解决方法二:一图多态
例题2: 如图所示,两质点A 、B 质量分别为m 、2m ,用两根等长的细轻绳悬挂在O 点,两球之间夹着一根劲度系数为k 的轻弹簧,静止不动时,两根细线之间的夹角为60°。设绳OA 、OB 与竖直方向的夹角分别为α和β,则( B ) A. βα2= B. βαsin 2sin = C. βαtan 2tan = D. βα2cos cos = 方法一:共交力系法(力矩平衡): 方法二:一图多态
例题3:(一图多态、共点力)如图所示,两个可视为质点的小球a 和b ,用一不计重力的刚性轻细杆相连,再用两根等长的轻细绳吊在O 点。已知小球a 和b 的质量之比a m :b m =1:3,细杆长度是细绳长度的2倍。两球处于平衡状态时,细杆与水平面的夹角为θ,绳Oa 上的拉力为a F ,绳Ob 上的拉力为b F ,则下列说法正确的是( B ) A. ?=30θ B.?=15θ C.1:3:=b a F F D.2:2:=b a F F 解题法:
练习1:(一图多态、共点力)如图所示,一轻质细杆两端分别固定着质量为mA 和mB 的两个小球A 和B(可视为质点),将其放在一个直角形光滑槽中,已知轻杆与槽右壁成α角,槽右壁与水平地面成θ角时,两球刚好能平衡,且α≠0,则A. B 两小球质量之比为( C ) A. sin θsin αcos θcos α?? B. cos θ sin αsin θcos α?? C.cos θcos αsin θsin α?? D. cos θcos αcos θsin α?? 练习2:(一图多态、共点力)如图所示,一个半球形的碗放在桌面上,碗口水平,O 是球心,碗的内表面光滑。一根轻质杆的两端固定有两个小球,质量分别是m1,m2.当它们静止时,m 1、m 2与球心的连线跟水平面分别成60°,30°角,则碗对两小球 的弹力大小之比是( B ) A. 1:2 B. 1:3 C. 3:1 D. 2:3 练习3:如图所示,在墙角有一根质量为m 的均匀绳,一端悬于天花板上的A 点,另一端悬于竖直墙壁上的B 点,平衡后最低点为C 点,测得AC =2BC ,且绳在B 端附近的切线与墙壁夹角为α,已知重力加速度为g ,则绳在A 处的张力是________,在最低点C 处的张力是________。 答案:α2tan 43mg += A T αmgtan 3 1=C T
C++的多态性实现机制剖析 ――即VC++视频第三课this指针详细说明 作者:孙鑫时间:2006年1月12日星期四 1.多态性和虚函数 我们先看一个例子: 例1- 1 #include
1、 编译的角度 C++编译器在编译的时候,要确定每个对象调用的函数的地址,这称为早期绑定(early binding ),当我们将fish 类的对象fh 的地址赋给pAn 时,C++编译器进行了类型转换,此时C++编译器认为变量pAn 保存的就是animal 对象的地址。当在main()函数中执行pAn->breathe()时,调用的当然就是animal 对象的breathe 函数。 2、 内存模型的角度 我们给出了fish 对象内存模型,如下图所示: 图1- 1 fish 类对象的内存模型 我们构造fish 类的对象时,首先要调用animal 类的构造函数去构造animal 类的对象,然后才调用fish 类的构造函数完成自身部分的构造,从而拼接出一个完整的fish 对象。当我们将fish 类的对象转换为animal 类型时,该对象就被认为是原对象整个内存模型的上半部分,也就是图1-1中的“animal 的对象所占内存”。那么当我们利用类型转换后的对象指针去调用它的方法时,当然也就是调用它所在的内存中的方法。因此,输出animal breathe ,也就顺理成章了。 正如很多学员所想,在例1-1的程序中,我们知道pAn 实际指向的是fish 类的对象,我们希望输出的结果是鱼的呼吸方法,即调用fish 类的breathe 方法。这个时候,就该轮到虚函数登场了。 前面输出的结果是因为编译器在编译的时候,就已经确定了对象调用的函数的地址,要解决这个问题就要使用迟绑定(late binding )技术。当编译器使用迟绑定时,就会在运行时再去确定对象的类型以及正确的调用函数。而要让编译器采用迟绑定,就要在基类中声明函数时使用virtual 关键字(注意,这是必须的,很多学员就是因为没有使用虚函数而写出很多错误的例子),这样的函数我们称为虚函数。一旦某个函数在基类中声明为virtual ,那么在所有的派生类中该函数都是virtual ,而不需要再显式地声明为virtual 。 下面修改例1-1的代码,将animal 类中的breathe()函数声明为virtual ,如下: 例1- 2 #include
福建农林大学实验报告 实验6 多态性(一) 一、实验目的和要求 (1)掌握虚函数的定义与使用方法,进一步理解多态性的概念和分类。 (2)了解纯虚函数和抽象类的使用方法。 二、实验内容和原理 1、分析并调试下列程序,回答以下问题:(1)指出抽象类(2)指出虚函数,并说明它的作用(3)每个类的作用是什么?整个程序的作用是什么? 2、使用虚函数编写程序求球体、圆柱体和圆锥的体积,由于球体、圆柱体和圆锥都可以看做由圆继 承而来,所以可以定义圆类作为基类。在圆类中定义数据成员半径和一个求体积的虚函数。由圆类 派生出球体类、圆柱体类和圆锥类,在派生类中对圆类中的虚函数重新定义。编写一个外部函数求 各类形状的总体积。最后在main()函数中构造若干形状,并求它们的体积和。
三、实验环境 1. 硬件:PC机; 2. 软件:Windows操作系统、Visual C++ 6.0 四、算法描述及实验步骤 1、算法描述及步骤如下: (1)根据题目要求编写好程序代码并在VC环境下输入源程序。 (2)检查程序有无错误(包括语法错误和逻辑错误),有则改之。 (3)编译和连接,仔细分析编译信息,如有错误应找出原因并改正之。本题改正后的代码如下: #include 第七章继承多态 一、选择题: 1、分析: class A { A() { } } class B extends A { //系统自动生成的构造方法和类的访问权限一样 } 哪两种说法是正确的? ( ) A:类B的构造方法是public的. B:类B的构造方法包含对this()的调用. C:类B的构造方法没有参数. D:类B的构造方法包含对super()的调用. 2、运行结果是:() class Base { Base() { System.out.print("Base"); } } public class Alpha extends Base { public static void main( String[] args ) { new Alpha(); new Base(); } } A: Base B: BaseBase C: 编译失败. D: 没有输出. E: 运行时异常. 3. 程序的运行结果是?() A: 编译失败. B: hello from a C: hello from b D: hello from b E: hello from a hello from a hello from b 4. 运行结果是:() class TestSuper { TestSuper(int i) { } } class TestSub extends TestSuper{ } class TestAll { public static void main (String [] args) { new TestSub(); } } A: 编译失败. B: 程序运行没有异常. C: 第7行抛出异常. D: 第2行抛出异常. 5. 程序的运行结果是?() A: 0 B: 1 C: 2 D: 编译失败. 6. 对于语句"B is a D" 和"B has a C",一下哪两种说法是正确的? ( ) A:D是B. B:B是D. C:D是C. D:B是C. E:D继承B. F:B 继承D. 7. 运行结果是?() 1. 什么是多态 多态是C++中的一个重要的基础,可以这样说,不掌握多态就是C++的门个汉。我就给它定一个这样的名字-- “调用’同名函数’却会因上下文不同会有不同的实现的一种机制”。这个名字长是长了点儿,可是比“多态”清楚多了。看这个长的定义,我们可以从中找出多态的三个重要的部分。一是“相同函数名”,二是“依据上下文”,三是“实现却不同”。我们且把它们叫做多态三要素吧。 2. 多态带来的好处 多态带来两个明显的好处:一是不用记大量的函数名了,二是它会依据调用时的上下文来确定实现。确定实现的过程由C++本身完成,另外还有一个不明显但却很重要的好处是:带来了面向对象的编程。 3. C++中实现多态的方式 C++中共有三种实现多态的方式。由“容易说明白”到“不容易说明白”排序分别为: 第一种是函数重载;第二种是模板函数;第三种是虚函数。 4. 细说用函数重载实现的多态 函数重载是这样一种机制:允许有不同参数的函数有相同的名字。 具体一点讲就是:假如有如下三个函数: void test(int arg){} //函数1 void test(char arg){} //函数2 void test(int arg1,int arg2){} //函数3 如果在C中编译,将会得到一个名字冲突的错误而不能编译通过。在C++中这样做是合法的。可是当我们调用test的时候到底是会调用上面三个函数中的哪一个呢?这要依据你在调用时给的出的参数来决定。如下: test(5); //调用函数1 test('c');//调用函数2 test(4,5); //调用函数3 C++是如何做到这一点的呢?原来聪明的C++编译器在编译的时候悄悄的在我们的函数名上根据函数的参数的不同做了一些不同的记号。具体说如下: void test(int arg) //被标记为‘test有一个int型参数’void test(char arg) //被标记为‘test有一个char型的参数’void test(int arg1,int arg2) //被标记为‘test第一个参数是int型,第二个参数为int型’ 这样一来当我们进行对test的调用时,C++就可以根据调用时的参数来确定到底该用哪一个test函数了。噢,聪明的C++编译器。其实C++做标记做的比我上面所做的更聪明。我上面哪样的标记太长了。C++编译器用的标记要比我的短小的多。看看这个真正的C++的对这三个函数的标记: ?test@@YAXD@Z ?test@@YAXH@Z ?test@@YAXHH@Z 是不是短多了。但却不好看明白了。好在这是给计算机看的,人看不大明白是可以理解的。 还记得cout吧。我们用<<可以让它把任意类型的数据输出。比如可以象下面那样: cout << 1; //输出int型 cout << 8.9; //输出double型 实验08:继承与多态 实验学时:6 实验类型:验证、设计 实验要求:必修 一、实验目的 1.理解继承的概念,了解面向对象设计中继承和多态的合理性; 2.掌握派生类的构造与析构; 3.掌握在对象中使用类层次和继承思想进行设计、实现和测试; 4.区别运行时的多态性的实现,理解重载与同名覆盖的差异; 5.理解虚函数与多态性; 6.实现运行时多态性的程序设计。 二、实验内容 1.Difine a class called PartFileledArrayWMax that is a derived class of the class PartFilledArray. The class PartFilledArrayWMax has one additional member variable named max_value that holds the maximum value stored in the array. Define a member accessor function named get_max that returns the maximum value stored in the array. Redefine the member function add_value and define two constructors, one of which has an int argument for the maximum number of entries in the array. Also define a copy constructor, an overloaded assignment operator, and a destructor. (A real class would have more member functions, but these will do for an exercise.) 2.某公司雇员(employee)包括经理(Manager)、技术人员(Technician)和销售员(Saleman)。开发部经理(developermanager)既是经理也是技术人员,销售部经理(salesmanager)既是经理也是销售员。 以employee类为虚基类,派生出manager、technician和saleman类,再进一步派生出developermanager和salesmanager类。 Employee类的属性包括姓名、职工号、工资级别、月薪(实发基本工资加业绩工资);操作包括月薪计算函数pay(),该函数要求输入请假天数,扣除应扣工第七章继承多态练习题
C++对多态的理解
实验8_继承和多态
实验八 多态性