CSE 143 Sample Final Exam #1
1. Inheritance and Polymorphism.
Consider the following classes
(System.out.println has been
abbreviated as S.o.pln):
public class Cup extends Box { public void method1() {
S.o.pln("Cup 1");
}
public void method2() {
S.o.pln("Cup 2");
super.method2();
}
}
public class Pill {
public void method2() {
S.o.pln("Pill 2");
}
}
public class Jar extends Box { public void method1() {
S.o.pln("Jar 1");
}
public void method2() {
S.o.pln("Jar 2");
}
}
public class Box extends Pill { public void method2() {
S.o.pln("Box 2");
}
public void method3() {
method2();
S.o.pln("Box 3");
}
}
The following variables are defined: Box var1 = new Box();
Pill var2 = new Jar();
Box var3 = new Cup();
Box var4 = new Jar();
Object var5 = new Box();
Pill var6 = new Pill(); In the table below, indicate in the right-hand column the output produced by the statement in the left-hand column. If the statement produces more than one line of output, indicate the line breaks with slashes as in "a / b / c" to indicate three lines of output with "a" followed by "b" followed by "c". If the statement causes an error, fill in the right-hand column with the phrase "error" to indicate this.
Statement
var1.method2();
var2.method2();
var3.method2();
var4.method2();
var5.method2();
var6.method2();
var1.method3();
var2.method3();
var3.method3();
var4.method3();
((Cup) var1).method1();
((Jar) var2).method1();
((Cup) var3).method1();
((Cup) var4).method1();
((Jar) var4).method2();
((Box) var5).method2();
((Pill) var5).method3();
((Jar) var2).method3();
((Cup) var3).method3();
((Cup) var5).method3();
Output
_________________________
_________________________
_________________________
_________________________
_________________________
_________________________
_________________________
_________________________
_________________________
_________________________
_________________________
_________________________
_________________________
_________________________
_________________________
_________________________
_________________________
_________________________
_________________________
_________________________
共交力系及一图多态小专 例题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
实验四类的继承与多态 一、实验目的 1.掌握构造方法和成员方法重载的应用。 2.理解类的继承性的作用 3.领会面向对象编程的多态性。 二、实验内容与要求 基本概念 1．进一步理解继承的含义 新类可从现有的类中产生，并保留现有类的成员变量和方法并可根据需要对它们加以修改。新类还可添加新的变量和方法。这种现象就称为类的继承。 当建立一个新类时，不必写出全部成员变量和成员方法。只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。被继承的类称为父类或超类（superclass），这个新类称为子类。 Java 提供了一个庞大的类库让开发人员继承和使用。设计这些类是出于公用的目的，因此，很少 有某个类恰恰满足你的需要。你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。所以，通常要对子类进行扩展，即添加新的属性和方法。这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。继承的意义就在于此。 2．了解成员变量的隐藏方式 所谓隐藏是指子类重新定义了父类中的同名变量，在子类L ine 中重新定义了x为x1，y 为y1，隐藏了父类Point 中的两个成员变量x 和y。子类执行自己的方法时，操作的是子类的变量，子类执行父类的方法时，操作的是父类的变量。在子类中要特别注意成员变量的命名，防止无意中隐藏了父类的关键成员变量，这有可能给程序带来麻烦。 3．了解成员方法的覆盖方式 （1）方法覆盖的定义与作用通过继承子类可以继承父类中所有可以被子类访问的成员方法，但如果子类的方法与父类方法同名，则不能继承，此时称子类的方法覆盖了父类的方法，简称为方法覆盖（override）。方法覆盖为子类提供了修改父类成员方法的能力。 4．理解类的多态性类的继承发生在多个类之间，而类的多态只发生在同一个类上。在一个类中，可以定义多个同名的方法，只要确定它们的参数个数和类型不同。这种现象称为类的多态。多态使程序简洁，为程序员带来很大便利。在O OP 中，当程序要实现多个相近的功能时，就给相应的方法起一个共同的名字，用不同的参数代表不同的功能。这样，在使用方法时不论传递什么参数，只要能被程序识别就可以得到确定的结果。 类的多态性体现在方法的重载（overload）上，包括成员方法和构造方法的重载。 实践应用
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米或更小，质量极小，但是密度极大，量子纠缠是通过量子“元”形成的密度引力相互作用的，使相干量子纠缠。 其实，不仅微观世界是多态的，宏观世界也是多态的。例如一张桌子，我们不同的感觉器官感觉它，会出现不同的存在“状态”，用眼睛看我们能得到桌子的形状，并不能知道桌子的其他性质，例如硬度、味道等。我们把盲人摸象的现象应用到量子的多态现象是非常形象
继承与多态习题 一.基本概念与基础知识自测题 8.1填空题 8.1.1 如果类α继承了类β，则类α称为（1）类，而类β称为（2）类。（3）类 的对象可作为（4）类的对象处理，反过来不行，因为（5）。如果强制转换则要注意（6）。 答案：（1）基类 （2）派生类 （3）派生类 （4）基类 （5）派生类有一些新成员 （6）只能派生类强制转换为基类 8.1.2 当用public继承从基类派生一个类时，基类的public成员成为派生类的（1）成员， protected成员成为派生类的（2）成员，对private成员是（3）。公有派生可以使其类的（4），所以公有派生是主流。 答案：（1）public成员 （2）protected成员 （3）不可访问 （4）接口不变 8.1.3 利用继承能够实现（1）。这种实现缩短了程序开发的时间，VC++中的（2）很 好地体现了这一点。 答案：（1）代码的复用 （2）MFC编程 8.1.4 一个派生类只有一个直接基类的情况称为（1），而有多个直接基类的情况称为 （2）。继承体现了类的（3）概念，这在MFC中得到了很好表现，MFC中只采用了（4）。 答案：（1）单继承 （2）多重继承 （3）层次 （4）单继承 8.1.5 C++中多态性包括两种多态性：（1）和（2）。前者是通过（3）实现的， 而后者是通过（4）和（5）来实现的。 答案：（1）编译时的 （2）运行时的 （3）函数和运算符的重载 （4）类继承关系 （5）虚函数 8.1.6 在基类中将一个成员函数说明成虚函数后，在其派生类中只要（1）、（2）和
（3）完全一样就认为是虚函数，而不必再加关键字（4）。如有任何不同，则认为是（5）而不是虚函数。除了非成员函数不能作为虚函数外，（6）、（7）和（8）也不能作为虚函数。 答案：（1）同虚函数名 （2）同参数表 （3）同返回类型。如基类中返回基类指针，而派生类中返回派生类指针是允许的 （4）virtual （5）重载 （6）静态成员函数 （7）内联函数 （8）构造函数 8.1.7 纯虚函数定义时在函数参数表后加（1），它表明程序员对函数（2），其本质 是将指向函数体的指针定为（3）。 答案：（1）=0 （2）不定义 （3）NULL 8.2简答题 8.2.1构造函数和析构函数可以继承吗？派生类构造函数各部分的执行次序是怎样的？答：构造函数和析构函数不可以继承。派生类构造函数各部分的执行次序是： 1.调用基类构造函数，按它们在派生类声明的先后顺序，依次调用。 2.调用新增成员对象的构造函数，按它们在类定义中声明的先后顺序，依次调用。 3.派生类的构造函数体中的操作。 8.2.2什么叫派生类的同名覆盖（override）? 答：如果派生类声明了一个和某个基类成员同名的新成员（当然如是成员函数，参数表也必须一样，否则是重载），派生类中的新成员就屏蔽了基类同名成员，类似函数中的局部变量屏蔽全局变量。称为同名覆盖（override）。 8.2.3派生类的析构函数中需完成什么任务？是否要编写对基数和成员对象的析构函数的 调用？为什么？ 答：析构函数的功能是作善后工作，析构函数无返回类型也没有参数，情况比较简单。派生类析构函数定义格式与非派生类无任何差异，不要编写对基数和成员对象的析构函数的调用，只要在函数体内把派生类新增一般成员处理好就可以了，因为对新增的成员对象和基类的善后工作，系统会自己调用成员对象和基类的析构函数来完成。 8.2.4为什么要使用虚基类？怎样定义虚基类？用一个实例来解释虚基类在其派生类中的 存储方式。 答：在多重继承是有可能出现同一基类的两个拷贝，为避免这种情况，可使用虚基类。虚基类（virtual base class）定义方式如下： class派生类名:virtual 访问限定符基类类名{...}; class派生类名:访问限定符virtual基类类名{...}; virtual 关键字只对紧随其后的基类名起作用。
多态：对于多态的实现，有三个关键字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.doczj.com/doc/dd12020668.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
西安邮电大学 （计算机学院） 课内实验报告 实验名称：继承与多态 专业名称：计算机科学与技术 班级：计科1405班 学生姓名：高宏伟 学号：04141152 指导教师：刘霞林 实验日期：2016.10.13
一、实验目的 通过编程和上机实验理解Java 语言的继承和多态特性，掌握变量的隐藏、方法的覆盖、重载，掌握抽象类和接口的使用。 二、实验要求 1.编写体现类的继承性（成员变量、成员方法、成员变量隐藏）的程序。 2.编写体现类的多态性（成员方法重载）的程序。 3.编写体现类的多态性（构造方法重载）的程序。 4.编写使用接口的程序。 三、实验内容 （一）类的继承 1.创建公共类Student. （1）编写程序文件Student.java，源代码如下: public class Student { protected String name; //具有保护修饰符的成员变量 protected int number; void setData(String m,int h) //设置数据的方法 { name =m; number= h; } public void print() //输出数据的方法 { System.out.println(name+", "+number); } } （2）编译Student.java，产生类文件Student.class。 2．创建继承的类Undergraduate
（1）程序功能：通过Student 类产生子类undergraduate，其不仅具有父类的成员变量name（）、number（学号），还定义了新成员变量academy（学院）、department （系）。在程序中调用父类的print 方法。 （2）编写Undergraduate 程序: class Undergraduate extends Student { 【代码1】//定义成员变量academy 【代码2】//定义成员变量department public static void main(String args[]) { 【代码3】//创建一个学生对象s 【代码4】//用父类的setData方法初始化对象s 【代码5】//对象s调用print方法 【代码6】//创建一个大学生对象u 【代码7】//调用父类的成员方法setData初始化对象u 【代码8】//设置对象u的成员变量academy 【代码9】//设置对象u的成员变量department System.out.print(https://www.doczj.com/doc/dd12020668.html,+", "+u.number+", "+u.academy+", "+u.department); } } （3）编译并运行程序 注意：公共类Student 与undergraduate 类要在同一文件夹（路径）。 (二)方法的重载 （1）程序功能：对不同的数进行排序输出。在IntSort 类中定义3 个同名的方法sort。 （2）编写Sort.java 文件，源代码如下。 import java.awt.Graphics; import java.applet.Applet; class IntSort { public String sort(int a, int b) { if (a>b) return a+""+b; else return b+""+a; } public String sort(int a, int b, int c) { int swap; if (a 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)子类重定义从父类继承来的成员 当子类从父类继承来的成员不适合子类时,子类不能删除它们,但可以重定义它们,使弗雷成员适应子类的新需求.子类重定义父类成员,同名成员在父类与子类之间表现出多态性,父类对象引用父类成员,子类对象引用子类成员,不会产生冲突和混乱. 子类可重定义父类的同名成员变量,称子类隐藏父类成员变量.子类也可以重定义父类的同名成员方法，当子类方法的参数列表与父类方法参数列表完全相同时，称为子类方法覆盖java多态性
java多态
相关主题
文本预览