4.多态
多态
0.英语单词
1.为什么使用多态
1)问题的由来
需求变更
宠物系统中添加主人给宠物喂食功能，具体需求如下：
?给Dog喂食，其健康值增加3，输出吃饱的信息
?给Penguin喂食，其健康值增加5，输出吃饱的信息
分析
1)给抽象类Pet增加抽象方法eat()方法；
2)让Dog类重写Pet类的eat()方法，实现狗狗吃饭功能；
3)让Penguin类重写Pet类的eat()方法，实现企鹅吃饭功能
4)创建主人类Master,添加feed(Dog dog)方法，调用Dog类的eat()方法，实现狗狗的
喂养；添加feed(Penguin penguin)方法，调用Penguin类的eat()方法，实现企鹅的喂
养。
5)创建测试类Test，在类中创建主人、狗狗和企鹅对象，调用相应方法实现主人喂养
宠物的功能
实例1：Pet.java Dog.java Penguin.java Master.java Test.java
从实例的运行结果看，我们已经顺利实现了主人给宠物喂食的功能，但是，如果主人又领养了一只猫或更多的宠物，该如何实现给宠物喂食呢？
当然你可以添加一个Cat类，让其继承Pet类，重写eat()方法；然后在Master类中重载feed()方法，添加一个feed(Cat cat)方法。可是，如果添加更多的宠物呢，这样做的缺点是：代码频繁修改（每次都要修改Master类，添加feed()的重载方法），可扩展性、可维护性差（如果领养的宠物过多，Master类中就会有很多重载的feed()方法）。
2)怎么解决问题
如果能实现如下效果就好了：Master类中只有一个feed()方法，可以实现多有宠物的喂食，不管领养多少宠物，都不用修改Master类源码。
答案是肯定的，通过多态实现该效果。
2.什么是多态？
简单来说，多态(Polymorphism)是具有表现多种形态的能力的特征，更专业化的说法是：同一个引用类型（父类或接口相同），使用不同的实例而执行不同的操作。
生活案例1：花木兰替父从军
生活案例2：打印机
3.Java中如何实现多态
1）子类到父类的转换（向上转型）
将一个父类的引用指向一个子类对象，称为向上转型(upcasting),自动类型转换；
案例：类型转换Test2.java
2）使用父类作为方法形参实现多态
4.实现多态的条件
1)继承的存在，继承是多态的前提，没有继承就没有多态
2)子类重写父类的方法（多态下调用子类重写后的方法）
3)父类引用指向子类对象（子类到父类的转换或使用父类作为方法形参）
5.Java中使用多态应该注意的问题
1)通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法。
2)通过父类引用变量无法调用子类特有的方法。
在第二点中，如果要调用子类特有的方法，需要使用多态的另外一个技能：父类到子类的转换，同时会使用instanceof运算符来判断类型的转换。将一个指向子类对象的父类引用赋值给一个子类的引用，称为向下类型转换，此时必须进行类型转换。
实例：classCastException
instanceof运算符对象instanceof 类或接口
实例：使用instanceof避免classCastException
注意：使用instanceof时，对象的类型必须和instanceof的第二个参数所指定的类或接口在继承树上有上下级关系，否则会出现编译错误。例如：pet instanceof String, 会出现编译错误。Instanceof通常和强制类型转换结合使用
6.作业
1）使用多态实现主人与宠物玩耍功能
主人和狗狗玩接飞盘的游戏，狗狗健康值减少10，亲密度增加5；主人和企鹅玩游戏，企鹅健康值减少10，亲密度增加5.实现主人和狗狗、企鹅玩耍的功能
实现思路
给Dog类添加catchFlyDisc()方法，实现接飞盘功能。
给Penguin类添加swim()方法，实现游泳功能。
给Master类添加play(Pet pet)方法，如果pet代表Dog就玩接飞盘；如果pet代表Penguin就玩游泳游戏。
创建测试类Test,在类中创建主人，狗狗和企鹅对象，调用相应的方法实现玩耍的功能。
注意编写注释
2）计算一次租赁多辆汽车的总租金。
上次作业中我们已经实现了汽车租赁系统的简单计价功能，客户可以租赁一辆某种型号的汽车若干天。现在增加业务需求：客户可以一次租赁多辆不同品牌的不同型号的汽车若干天（一个客户一次租赁的各汽车的租赁天数均相同），要求计算总租赁价。
实现思路：
?在上次“汽车租赁系统计价功能”的基础上进行完善，可以复用该练习的代码；
?创建顾客类Customer,提供calcTotalRent(MotoVehicle motos[], int days)方法，传入的参数
是客户租赁的汽车列表信息和租赁天数，在方法中调用相应汽车的calRent(int days)方法得到相应的租赁价格，求和计算出多辆汽车总租赁价格。
?编写测试类TestRent,指定要租赁的多辆汽车信息，并存储在一个MotoVehicle类型数组
motos中，指定要租赁天数，调用Customer类的calcTotalRent(MotoVehicle moto[], int days)方法计算出总租赁价格并输出。
int[] array = new int[5];
MotoVehicle[] mvArray = new MotoVehicle[5];
class Customer{
Public int clcTotalRent(MotoVehicle motos[], int days){
Int sum =0;
For(int i =0 ; i Sum=sum+ Motos[i].calRent(days) } Return sum; } } class TestRent{ Public static void main(){ MotoVehicle motos[] = { New Car(“”,””), New Bus(“金杯”,”20”), } } } 共交力系及一图多态小专 例题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 第七章继承多态 一、选择题： 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()，该函数要求输入请假天数，扣除应扣工 Java多态的综合例子: package Test; public interface USBInterface { void start(); void conn(); void stop(); } package Test; public class MovingDisk implements USBInterface { @Override public void start() { // TODO Auto- System.out.println("移动设备已经插入，开始使用"); } @Override public void conn() { // TODO Auto-generated method stub System.out.println("移动设备已经连接，正在使用"); } @Override public void stop() { // TODO Auto-generated method stub System.out.println("移动设备已经退出"); } } package Test; public class Mouse implements USBInterface { public void start() { System.out.println("鼠标已插入，开始使用"); } @Override public void conn() { System.out.println("鼠标已经连接，正在使用中"); } @Override public void stop() { System.out.println("鼠标拨出"); } } package Test; public class MainBorad { public void start() { System.out.println("主板加载成功"); } public void useUsb(USBInterface u) { u.conn(); u.start(); u.stop(); } } package Test; public class KeyBoard implements USBInterface { @Override public void start() { System.out.println("键盘已经插入，开始使用"); } @Override public void conn() { // TODO Auto-generated method stub System.out.println("键盘已经连接，正在使用"); } @Override public void stop() { // TODO Auto-generated method stub System.out.println("键盘已经拨出"); } } package Test; public class Test { /** * @param args Java中的多态用法实例分析 多态分两种： (1)编译时多态（设计时多态）：方法重载。 (2)运行时多态：JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。（我们平时说得多的事运行时多态，所以多态主要也是指运行时多态） 运行时多态存在的三个必要条件： 一、要有继承（包括接口的实现）； 二、要有重写； 三、父类引用指向子类对象。 详细解释： 运行时多态的解释：a.运行时多态是指程序中定义的引用变量所指向的具体类型和b.通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定. 1.程序序中定义的引用变量所指向的具体类型不确定(即一个引用变量倒底会指向哪个类的实例对象)。 例子： driver类中drive方法（Vehicle类vehicle）{} oneDriver.drive(newcar()) oneDriver.drive(newbus()) 其中vehicle变量无法确定具体使用哪个子类实例。 1.通过该引用变量发出的方法调用在编程时并不确定(该引用 变量发出的方法调用到底是哪个类中实现的方法)。 例子:厨师，园丁，理发师的Cut方法调用.persion.cut(). 多态的好处： 1.可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。 2.可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。 3.接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3所示。图中超类Shape规定了两个实现多态的接口方法，puteArea()以及puteVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。 4.灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。 5.简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。 多态的量子、多态的世界 我们知道，量子是最基本的能量单位，可以说是能量的最小单位，所有的微观粒子包括分子、原子、电子、光子他们都是量子的一种表现形态。其实，我们的这个世界本身都是微观粒子组成的，准确地说，整个自然界本身都是由量子组成的，宏观世界也是量子的一种表现形态。 量子的多态表现为，量子的状态没有被观察时，它是多态的，一旦被观察，则只能存在一个能量的状态。我们回忆薛定谔猫理论：设想在一个封闭的匣子里，有一只活猫及一瓶毒药。当衰变发生时，药瓶被打破，猫将被毒死。按照常识，猫可能死了，也可能还活着。量子力学告诉我们，存在一个中间态，猫既不死也不活，直到进行观察看看发生了什么。量子力学告诉我们：除非进行观测，否则一切都不是确定的，可这使微观不确定原理变成了宏观不确定原理，客观规律不以人的意志为转移，猫既活又死违背了逻辑思维。我们分析薛定谔猫论的假设，匣子、毒药、猫——构成了一个统一体，这一状态猫命悬一线本身就是多态的，从某种意义上讲匣子、毒药已经是猫生存的一部分，只是他们之间是否相互作用，不相互作用，等于毒药不存在，猫存活；相互作用，猫死。在匣子的存在下，我们不观察，真的不知道是否相互作用，只能是生、死共存状态。 托马斯·杨的双缝实验，量子力学认为，观察时光子走单缝，不观察时走双缝。只取决于你测量这个物体的方式。从量子学角度看，如 果你不观察它，那么现实并不存在或是模糊的、多态的，尽管听上去非常怪异，但结果证实了量子理论的正确性。例如光子，如果你用平面镜、水等手段研究光子的性质，那么光子具有粒子性——折射、反射；如果你用类似于双缝实验的手段测量光子的性质，光子即表现为波动性。 叠加的多态量子，有人为的，更多的是自然的，观察、测量时，测量的手段、方法解除了量子的多态，即确认量子的存在状态——唯一性。叠加即量子的分身，就是量子处在不稳定的、随时可变的多重状态，测量时即确定量子多态的哪一种状态。量子纠缠其实就是量子或多态量子之间的相互作用，纠缠就是量子之间的相互吸引，既然是相互吸引，不论纠缠的量子距离多远，相互纠缠的量子其中的一个量子的运动状态被改变，另一个量子的运动状态也必然随着改变。犹如天文观察到的相互绕转的双星，假设双星中的一个由于某种原因，例如爆炸损失一部分，双星的另一个运动状态必然改变。理论推测，组成量子的“元”，半径极短约在10-24米或更小，质量极小，但是密度极大，量子纠缠是通过量子“元”形成的密度引力相互作用的，使相干量子纠缠。 其实，不仅微观世界是多态的，宏观世界也是多态的。例如一张桌子，我们不同的感觉器官感觉它，会出现不同的存在“状态”，用眼睛看我们能得到桌子的形状，并不能知道桌子的其他性质，例如硬度、味道等。我们把盲人摸象的现象应用到量子的多态现象是非常形象 多态：对于多态的实现，有三个关键字new，virtual，override的使用，多态可以简单的理解为对不同的对象调用相同的方法，表现出不同的行为，这种特性是通过继承来实现的。 例1： public class Animal { public virtual void Eat() { Console.WriteLine("Animal eat"); } } public class Cat : Animal { public override void Eat() { Console.WriteLine("Cat eat"); } } public class Dog : Animal { public override void Eat() { Console.WriteLine("Dog eat"); } } class Tester { static void Main(string[] args) { Animal[] animals = new Animal[3]; animals[0] = new Animal(); animals[1] = new Cat(); animals[2] = new Dog(); for (int i = 0; i < 3; i++) { animals[i].Eat(); } } } 输出如下： Animal eat... Cat eat... Dog eat... 在上面的例子中，通过继承，使得Animal对象数组中的不同的对象，在调用Eat()方法时，表现出了不同的行为。 1. new的用法 例2： public class Animal { 实验4 类的继承和多态机制 一、实验目的 1、掌握类的继承机制； 2、掌握子类对父类构造方法的调用； 3、掌握方法覆盖和方法重载的区别。 二、实验内容 1、定义点类Point、圆类Circle、圆柱体类Cylinder。实现继承关系。 2、定义交通工具类Vehicle，一个小车类Car。实现Car对Vehicle的继承。 三、实验步骤 1、定义点类Point、圆类Circle、圆柱体类Cylinder。实现继承关系。 设计一个表示二维平面上点的类Point，包括表示坐标位置的成员变量x和y，获取和设置x和y值的方法。 设计一个表示二维平面上圆的类Circle，它继承自类Point，还包括表示圆半径的成员变量r、获取和设置r值的方法、计算圆面积的方法。 设计一个表示圆柱体的类Cylinder,它继承自类Circle，还包括表示圆柱体高的成员h、获取和设置h的方法、计算圆柱体表面积的方法、计算圆柱体体积的方法。 建立若干个Cylinder对象，输出其轴心位置坐标、半径、高、表面积及其体积的值。 class Point{ int x; int y; ;public Point(int x,int y){ this.x =x; this.y=y; } public int getX(){ return x; } public int getY(){ return y; } } class Circle extends Point{ double r; final double PI=3.1416; public Circle(int x,int y,double m){ super(x,y); r=m; } public double getR(){ return r; } public double circlearea(){ return PI*r*r; 实验名称 java类的继承和多态实验名称 Java类的继承和多态 一、实验目的 1、理解Java类的继承和多态的概念 2、掌握类的继承机制的实现 3、掌握方法的重载，以及多态的实现。 二、实验要求 1、本实验属于验证型和设计型实验。需要根据已给的源程序运行结果，并结合问题进行新的设计; 2、对实验过程中提出的问题进行解答; 3、完成实验报告。 三、实验内容与过程 1、上机运行下面的程序，并回答下面的问题。 public class ClassOne{ int num=100; public void compute(){ num-=50; } public static void main(String args[]){ ClassOne one=new ClassOne(); ClassTwo two=new ClassTwo(); System.out.println(“num of ClassTwo:”+two.num); System.out.println(“num of ClassOne:”+two.getNum()); https://www.wendangku.net/doc/604030312.html,pute(); System.out.println(“num of ClassTwo:”+two.num); System.out.println(“num of ClassOne:”+two.getNum()); } } class ClassTwo extends ClassOne{ int num=0; public void plus(){ num+=50; } public int getNum(){ return super.num; } } 问题: (1) 请指出Java面向对象编程中三个主要特性。 (2) Java中的继承机制是什么, (3) 请指出程序中关键字super的作用。 2、运行下面的程序，回答问题。class Monkey{ private int age=10; void speak(){ System.out.println("I am monkey."); } } 多态性是面向对象编程三个重要特性之一。Java中的多态性是通过综合应用继承、覆 盖，以及向上转型实现的。本章首先综合阐述面向对象编程的这些重要特征，引申到代码中的多态概念、多态带来的好处，以及多态能够解决的问题。然后通过实例详细讨论多态技术 在编程中的应用。 3：如何在程序中最有效地计算众多不同几何体的表面积comArea ()? 计算表面积的方法，如comArea，包括其 他类似方法，如comArea，print()，等等，都可应用多态来解决。因为这 些方法都可以针对不同的几何体，进行运算和操作。即：形态不一、方法相同、内容多样。 public abstract class shape { public double area(){ return 0; } public void print(){ } } public class sphere extends shape{ private double r; public sphere(double r){ this.r=r; } public void print(){ System.out.println("球的半径："+r); } public double area(){ return Math.PI*r*r*r*4/3; } } public class comArea { public static void main(String[] args) { shape h[]; h=new shape[2]; h[0]=new sphere(10); h[1]=new square(10,10,10); Operator.areaMax(h); } } public class Operator { //将长方形和圆看做Shape类型 public static void areaMax(shape h[]){ shape max; for(int i=1;i Java的多态性 面向对象编程有三个特征，即封装、继承和多态。 封装隐藏了类的内部实现机制，从而可以在不影响使用者的前提下改变类的内部结构，同时保护了数据。 继承是为了重用父类代码，同时为实现多态性作准备。那么什么是多态呢？ 方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念，原因之一是它在类的继承问题上和C++不同，后者允许多继承，这确实给其带来的非常强大的功能，但是复杂的继承关系也给C++开发者带来了更大的麻烦，为了规避风险，Java只允许单继承，派生类与基类间有IS-A的关系（即“猫”is a “动物”）。这样做虽然保证了继承关系的简单明了，但是势必在功能上有很大的限制，所以，Java引入了多态性的概念以弥补这点的不足，此外，抽象类和接口也是解决单继承规定限制的重要手段。同时，多态也是面向对象编程的精髓所在。 要理解多态性，首先要知道什么是“向上转型”。 我定义了一个子类Cat，它继承了Animal类，那么后者就是前者是父类。我可以通过 Cat c = new Cat(); 实例化一个Cat的对象，这个不难理解。但当我这样定义时： Animal a = new Cat(); 这代表什么意思呢？ 很简单，它表示我定义了一个Animal类型的引用，指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal，所以Animal类型的引用是可以指向Cat类型的对象的。那么这样做有什么意义呢？因为子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特， 定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。 所以，父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的； Java多态 1. Java中除了static和final方法外，其他所有的方法都是运行时绑定的。private 方法都被隐式指定为final的，因此final的方法不会在运行时绑定。当在派生类中重写基类中static、final、或private方法时，实质上是创建了一个新的方法。 2.在派生类中，对于基类中的private方法，最好采用不同的名字。 3.包含抽象方法的类叫做抽象类。注意定义里面包含这样的意思，只要类中包含一个抽象方法，该类就是抽象类。抽象类在派生中就是作为基类的角色，为不同的子类提供通用的接口。 4.对象清理的顺序和创建的顺序相反，当然前提是自己想手动清理对象，因为大家都知道Java垃圾回收器。 5.在基类的构造方法中小心调用基类中被重写的方法，这里涉及到对象初始化顺序。 6.构造方法是被隐式声明为static方法。 7.用继承表达行为间的差异，用字段表达状态上的变化。 在JAVA中有两种多态是指：运行时多态和编译时多态。 关于类的多态性简介如下： 多态(polymorphism)意为一个名字可具有多种语义.在程序设计语言中,多态性是指”一种定义,多种实现”.例如,运算符+有多种含义,究竟执行哪种运算取决于参加运算的操作数类型: 1+2 //加法运算符 “1” + “2” //字符串连接运算,操作数是字符串 多态性是面向对象的核心特征之一,类的多态性提供类中成员设计的灵活性和方法执行的多样性. 1、类多态性表现 (1)方法重载 重载表现为同一个类中方法的多态性.一个类生命多个重载方法就是为一种功能提供多种实现.编译时,根据方法实际参数的数据类型\个数和次序,决定究竟应该执行重载方法中的哪一个. (2)子类重定义从父类继承来的成员 当子类从父类继承来的成员不适合子类时,子类不能删除它们,但可以重定义它们,使弗雷成员适应子类的新需求.子类重定义父类成员,同名成员在父类与子类之间表现出多态性,父类对象引用父类成员,子类对象引用子类成员,不会产生冲突和混乱. 子类可重定义父类的同名成员变量,称子类隐藏父类成员变量.子类也可以重定义父类的同名成员方法，当子类方法的参数列表与父类方法参数列表完全相同时，称为子类方法覆盖 多态性 10.2 典型例题分析与解答 例题1：指出下列对定义重载函数的要求中，哪些是错误的提法。 A．要求参数的个数不同。 B.要求参数中至少有一个类型不同。 C．求函数的返回值不同。 D. 要求参数的个数相同时，参数类型不同。答案：C 例题3：下面关于友元的描述中，错误的是（）。 A. 友元函数可以访问该类的私有数据成员 B. 一个类的友元类中的成员函数都是这个类的友元函数 C. 友元可以提高程序的运行效率 D. 类与类之间的友元关系可以继承 答案：D 例题4：下述静态成员的特性中，（）是错误的。 A. 静态成员函数不能利用this指针 B. 静态数据成员要在类体外进行初始化 C. 引用静态数据成员时，要在静态数据成员名前加<类名>和作用域运算符 D. 静态数据成员不是所有对象所共有的 答案：D 例题5：关于虚函数的描述中，（）是正确的。 A. 虚函数是一个静态成员函数 B. 虚函数是一个非成员函数 C. 虚函数既可以在函数说明时定义，也可以在函数实现时定义 D. 派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型 参考答案：D 例题11：分析下列程序的输出结果。 #include C++多态性概念、作用及实例 概念 多态指同一个实体同时具有多种形式。它是面向对象程序设计（OOD）的一个重要特征。如果一个语言只支持类而不支持多态，只能说明它是基于对象的，而不是面向对象的。C++中的多态性具体体现在运行和编译两个方面。运行时多态是动态多态，其具体引用的对象在运行时才能确定。编译时多态是静态多态，在编译时就可以确定对象使用的形式。 C++中，实现多态有以下方法：虚函数，抽象类，重载，覆盖。 作用 把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。也就是说，父亲的行为像儿子，而不是儿子的行为像父亲。举个例子：从一个基类中派生，响应一个虚命令，产生不同的结果。比如从某个基类继承出多个对象，其基类有一个虚方法Tdoit，然后其子类也有这个方法，但行为不同，然后这些子对象中的任何一个可以赋给其基类的对象，这样其基类的对象就可以执行不同的操作了。实际上你是在通过其基类来访问其子对象的，你要做的就是一个赋值操作。 使用继承性的结果就是可以创建一个类的家族，在认识这个类的家族时，就是把导出类的对象当作基类的对象，这种认识又叫作upcasting。这样认识的重要性在于：我们可以只针对基类写出一段程序，但它可以适应于这个类的家族，因为编译器会自动就找出合适的对象来执行操作。这种现象又称为多态性。而实现多态性的手段又叫称动态绑定(dynamic binding)。 简单的说，建立一个父类的对象，它的内容可以是这个父类的，也可以是它的子类的,当子类拥有和父类同样的函数，当使用这个对象调用这个函数的时候，定义这个对象的类（也就是父类）里的同名函数将被调用，当在父类里的这个函数前加virtual关键字，那么子类的同名函数将被调用。 实例程序 #include 多态系统可靠性改善中的多态元件的关键性分析 摘要 本文用多态元件(MSMC)为多态系统评估并实施了复合重要措施(CIM)。重要措施常常被作为一种手段用来对系统内单个元件的影响和临界重要度进行评估和排名，然而很少被用作为系统可靠性改进方法的优先次序排序的导向。对于多态系统,先前开发的措施有时并不恰当,他们不能满足所有用户的需求。本研究有两个相关联的目标:第一,要区分两种类型的重要措施,他们就多态系统的可靠性可用MSMC评估部件的临界重要度；第二,基于CIM,发展一个分配启发式的组件来最大限度地改善系统可靠性。这种启发式用蒙特卡罗模拟的算法和最大流最小切割算法作为手段计算组件CIM。这些措施就变成了一个基于成本的复合权值,引导分配多余的元素融入现行体制中。不同的复杂系统的实验结果表明了这些新CIM就多态系统的可靠性能有效地估计组件的临界重要度。同样,这些结果表明,该基于启发式的CIM可以作为一种快速、有效的技术来引导系统可靠性的改进。 关键词：重要措施；多态系统；可靠性改进 Abstract This paper evaluates and implements composite importance measures (CIM) for multi-state systems with multi-state components (MSMC).Importance measures are frequently used as a means to evaluate and rank the impact and criticality of individual components within a system yet they are less often used as a guide to prioritize system reliability improvements. For multi-state systems, previously developed measures sometimes are not appropriate and they do not meet all user needs. This study has two inter-related goals: first, to distinguish between two types of importance measures that can be used for evaluating the criticality of components in MSMC with respect to multi-state system reliability, and second, based on the CIM, to develop a component allocation heuristic to maximize system reliability improvements. The heuristic uses Monte-Carlo simulation together with the max-flow min-cut algorithm as a means to compute component CIM. These measures are then transformed into a cost-based composite metric that guides the allocation of redundant elements into the existing system. Experimental results for different system complexities show that these new CIM can effectively estimate the criticality of components with respect to multi-state system reliability. Similarly, these results show that the CIM-based heuristic can be used as a fast and effective technique to guide system reliability improvements. Keywords: Importance measures; Multi-state systems; Reliability improvement 1介绍 一个系统设计中的特殊的组件的临界重要度是依据重要措施进行量化的。对于系统展示二进制功能行为(例如,系统和系统部件要么完全功能要么完全失败),Vasseur和Llory回顾了可靠性的成就(RＡW)、可靠性降低(RRW),Fussell-Veseley价值(FV)和黄宗玉最有价值和两个连接体的一图多态老师版
多态性实现机制
第七章继承多态练习题
C++对多态的理解
实验8_继承和多态
Java多态的综合例子
Java中的多态用法实例分析
多态的量子
多态的实现
实验4 类的继承和多态机制
实验名称 java类的继承和多态
java多态的实际应用
java多态性
java多态
c++多态性相关习题
多态性实例
多态系统可靠性