继承与多态习题

继承与多态习题

一.基本概念与基础知识自测题

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 关键字只对紧随其后的基类名起作用。

如下派生：

（a ）派生关系

（b ）存储图

存储关系如(b)，在职研究生类有两个Person 拷贝。采用虚基类后存储关系如下：

在职研究生类只有一个Person 拷贝。

8.2.5 简单叙述派生类与基类的赋值兼容规则。

答：凡是基类所能解决的问题，公有派生类都可以解决。在任何需要基类对象的地方都可以 采用虚基类后在职研究生类储存图

java实验报告2 继承多态 封装

实验报告 学生姓名：学号：专业班级： 实验类型：□验证□综合□设计□创新实验日期：实验成绩： 一、实验项目名称抽象、封装与类（一） 二、实验目的 1.掌握抽象、封装、继承和多态 2.熟练掌握如何自定义一个类。 3.掌握类的访问权限 4.掌握类成员的访问控制

三、实验基本原理 四、主要仪器设备及耗材 Myclipse 五、实验步骤 1、调试程序例3-4 2、编写如下程序。 （1）定义一个表示学生的类Student，包括属性“学号”、“班号”、“姓名”、“性别”、“年龄”；方法“获得学号”、“获得班号”、“获得姓名”、“获得性别”、“获得年龄”、“修改年龄”。 （2）为Student类定义构造函数初始化所有属性，增加一个方法public String toString()，把Student类对象的所有属性信息组合成一个字符串输出。 （3）在main()中创建Student类对象，测试自定义类。 六、实验数据及处理结果 1、package ncu;

public class Exam3_4 { static double d; public static void main(String args[]){ int i; Exam3_4 pt=new Exam3_4(); i=5; (i); "int type value is:"+i); =; (pt); "double type value is"+d); } public void changeInt(int v) {v=10;} public void changeDouble(Exam3_4 ref) {=;} }

继承与多态习题

继承与多态习题 一.基本概念与基础知识自测题 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 关键字只对紧随其后的基类名起作用。

JAVA继承和多态实验报告

实验项目名称：继承和多态 （所属课程：Java语言程序设计） 院系：专业班级：姓名： 学号：实验地点：指导老师： 本实验项目成绩：教师签字：日期： 1．实验目的 （1）掌握类的继承机制。 （2）熟悉类中成员变量和方法的访问控制。 （3）熟悉方法或构造方法多态性。 2.实验内容 （1）模拟编写程序，理解类的继承、多态、继承和多态规则。 （2）独立编程，实现类的继承和多态。 3.实验作业 设计一个类Shape（图形）包含求面积和周长的area()方法和perimeter()方法以及设置颜色的方法SetColor()，并利用Java多态技术设计其子类Circle（圆形）类、Rectangle （矩形）类和Triangle（三角形）类，并分别实现相应的求面积和求周长的方法。每个类都要覆盖toString方法。 海伦公式：三角形的面积等于s(s-a)(s-b)(s-c)的开方，其中s=(a+b+c)/2 程序代码为： Class包 package Class; public class Shape { private String color = "while"; public Shape(String color){ this.color = color; } public void setColor(String color){ this.color = color; } public String getColor(){ return color;

} public double getArea(){ return 0; } public double getPerimeter(){ return 0; } public String toString(){ return"color:" + color; } } package Class; public class Circle extends Shape { private double radius; public Circle(String color,double radius) { super(color); this.radius = radius; } public void setRadius(double radius){ this.radius = radius; } public double getRadius(){ return radius; } public double getCircleArea(){ return 3.14*radius*radius; } public double getCirclePerimeter(){ return 3.14*2*radius; } public String toString(){

第五章 类与继承作业一

第五章类与继承作业一 一、填空选择题 1、（在同一包中）子类不能继承父类中的私有成员，除此之外，其它所有的成员都可以通过继承变为子类的成员。 2、给出如下的程序，A-E选项中与构造方法ConstOver重载的两个构造方法是：AC。 .public class ConstOver { publicConstOver (int x, int y, int z) { } } A.ConstOver ( ) { } B.ProtectedintConstOver ( ) { } C.PrivateConstOver (int z, int y, byte x) { } D.public Object ConstOver (int x, int y, int z) { } E.public void ConstOver (byte x, byte y, byte z) { } 3、已知类关系如下： class Employee; class Manager extends Employeer; class Director extends Employee; 则以下关于数据的语句正确的是：（A）。 A. Employee e=new Manager(); B. Director d=new Manager(); C. Director d=new Employee(); D. Manager m=new Director(); 4、（A）下面对类的申明哪个是正确的？ A）public class Fred { publicint x = 0; public Fred (int x) { this.x = x; } } B）public class fred publicint x = 0; publicfred (int x) { this.x = x; } } C）public class Fred extends MyBaseClass, MyOtherBaseClass { publicint x = 0; public Fred (intxval) { x = xval; } } D）protected class Fred { privateint x = 0;

实验三 继承、多态和图形用户界面

实验三字符串与文本 （上课被教师验收的同学不用提交实验结果，并注意在教师处签名。未完成的同学请提交实验结果，即将程序直接粘贴至本DOC文件，并在邮件名的标题中注明：学号+姓名+实验三） 1.给出下面程序的输出： 2.直接给出下面程序的运行结果： “B’s constructor is invoked” “A’s constructor is invoked” 2. 下面的说法对的注明“True”，错的注明“False” （1）子类是父类的一个子集。（f）（2）当从子类调用一个构造函数时，它的父类的无参构造方法总是被调用。（f）（3）可以覆盖定义在父类中的私有方法。( f) （4）可以覆盖定义在父类中的静态方法。( f) (5) 如果子类中的一个方法和它的父类中的方法具有完全相同的方法头，但返回值 类型不同，也可以构成覆盖。( f) (6) 可以给面板添加一个框架。( f) (7) 可以给框架添加一个面板。( t ) 3. 指出下面程序中的问题：

有四处错误 给radius和length赋值要用this. 调用父类的构造方法Circle（）和getArea（）前需要加上关键字super 4.下面的程序是要在框架中显示一个按钮，但是什么也没有显示出来。这个程序有什么问 题？

Test()中没有创建实例对象 将new javax.swing.JFrame() 改成new Test() 5.填空： （1）在类上使用default修饰符，才能使同一个包中的类可以访问它，而不同包中的类不能访问它。 （2）在类上使用protected 修饰符，才能使不同包中的类不能访问这个类，而任何包中的子类可以访问它。 6. 在程序清单11-9中，MyStack是用组合实现的，现请扩展ArrayList，利用继承来实现MyStack。编写一个测试程序，提示用户输入五个字符串，然后以逆序显示这些字符串。 package Test03; public class MyStack extends java.util.ArrayList { public Object peek() { return this.get(size() - 1); } public Object pop() { Object o = this.get(size() - 1); this.remove(size() - 1);

Java继承与多态实验报告

西安邮电大学 （计算机学院） 课内实验报告 实验名称：继承与多态 专业名称：计算机科学与技术 班级：计科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/1c6574513.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编程技术》课程实验报告 院（系）名称：计算机学院专业班级：09计科 3 班 学号：姓名： 实验题目：实验10继承与多态 实验日期：2011/11/29实验（上机）学时：2 一、实验内容、要求 1.实验内容：计算课程成绩 2.要求： 编写应用程序，读入以下风格的文本文件，并显示最后的课程成绩，根据列出的公式，对于本科生和研究生，课程成绩的计算方法不同。输入的文本格式如下： （1）用单独的一行表示一个学生的信息。 （2）每行使用下面的格式： 其中，指明学生是研究生，还是本科生；指明学 生的姓和名；指明是第i次测试成绩。 （3）“END”指明输入的结束。字母的大小写不重要。 公式如下： 学生类型评分方案 本科生通过，如果(test1+test2+test3)/3>=70 研究生通过，如果(test1+test2+test3)/3>=80 实现一个类完成以下功能： （1）读入输入文本文件。

（2）计算课程成绩。 （3）输出结果。 我们将用五个增量步骤开发此程序： （1）以程序结构开始，定义ComputeGrades类的框架。 （2）实现printResult方法，定义实现printResult所必需的任何其他方法。 （3）实现computerGrades方法，定义实现computerGrades所必需的任何其他方法。 （4）实现readDate方法，定义实现readDate所必需的任何其他方 法。 （5）最后完成并改进。 二、所采用的数据结构 如：线性表，二叉树，树，图等。你在此用到了啥样的数据结构就写啥。无数据结构。 三、实验的主要模块（或函数）及其功能 函数分块及各块主要功能的文字描述 ComputGrades类:这是本程序的主类，且是MainWindow的子类。MainWindows本身是Jframe的子类，并且又将其自身放在屏幕中间的功能。ComputGrades类包含的方法如下： 1、构造方法。生成任意大小的数组，让程序员在构造方法中传递数组的 大小，不在构造方法中生成数组。 2、printResult方法。将学生信息机计算出来的成绩输出到OutputBox

实验五 继承与多态

实验五继承与多态 专业班级学号姓名 实验学时 2 实验类型验证性实验地点数计学院实验中心实验时间指导老师 实验成绩 年月日一、实验目的： 理解继承与多态的概念，掌握三种访问控制的区别，掌握抽象类、接口与包的应用。 二、实验内容： 1. 参考教材P124，示例程序C5_17，掌握抽象类的应用。 2. 参考教材P128，示例程序C5_18，掌握接口的使用方法。 3. 参考教材P133，示例程序C5_20，掌握包的使用方法。 三、实验要求： 1.完成示例程序的验证。 2.写出实验报告。 四、实验步骤与结果：（由学生按照实验内容完成） 程序一 package ch01; import java.applet.Applet; import java.awt.Graphics; abstract class Shapes //定义一个抽象类Shapes { public int x,y; //x、y为画图的坐标 public int width,height; public Shapes(int x,int y,int width,int height) { this.x=x; this.y=y; this.width=width; this.height=height; } abstract double getArea( ); //求图形面积的抽象方法 abstract double getPerimeter( ); //求图形周长的抽象方法 } class Square extends Shapes //由抽象类Shapes派生的子类——矩形类 { @Override public double getArea( ){return(width*height);} @Override public double getPerimeter( ){return(2*width+2*height);} public Square(int x,int y,int width,int height) { super(x,y,width,height); } }

实验报告(四)继承和多态 (完整代码)

福建农林大学计算机与信息学院实验报告 实验（四）继承和多态 一、实验目的和要求 1.掌握面向对象的继承关系 2.理解面向对象的多态 3.掌握方法的重写 4.掌握接口的实现 二、实验内容和原理 设计一个抽象类Shape，包括2个抽象方法，分别是计算形状的周长和面积。设计具体类Rectangle和Circle，分别表示矩形和圆，它们都是Shapes的子类。使Rectangle和Circle都实现Comparable接口（根据面积比较大小），编写一个通用的排序程序和一个通用的二分查找程序（自己写代码实现），能对这二种类型的数组进行排序并查找指定的对象。 三、实验环境 1.硬件环境： 2.软件环境：JDK1.5 四、算法描述及实验步骤 1.算法描述（可以用类图、流程图、伪代码或源程序描述） package test; import javax.swing.JOptionPane; import java.util.Scanner; public class Test { public static void main(String[] args) { System.out.println("要创建几个圆？：");

Scanner a1 = new Scanner(System.in); int a = a1.nextInt(); System.out.println("总共创建了" + a + "个圆\n请输入各个圆的半径："); Shape[] circle = new Shape[a]; Scanner input2 = new Scanner(System.in); for (int i = 0; i < a; i++) { circle[i] = new Circle(input2.nextDouble()); } System.out.println("要创建几个矩形？："); Scanner b2 = new Scanner(System.in); int b = b2.nextInt(); Shape[] rectangle = new Shape[b]; System.out.println("总共创建了" + b + "个矩形\n请依次输入各个矩形的长和宽："); Scanner c3 = new Scanner(System.in); for (int i = 0; i < b; i++) { rectangle[i] = new Rectangle(c3.nextDouble(), c3.nextDouble()); } Shape.sort(circle); String str1 = ""; for (int i = 0; i < circle.length; i++) { str1 += String.valueOf(i + 1) + circle[i] + "\n"; } System.out.println("您所创建的圆按半径由小到大排序如下：\n" + str1); Shape.sort(rectangle); String str2 = ""; for (int i = 0; i < rectangle.length; i++) { str2 += String.valueOf(i + 1) + rectangle[i] + "\n"; } System.out.println("您所创建的矩形按面积由小到大排序如下：\n" + str2);

实验四 、类的继承与多态

实验四类的继承与多态 一、实验目的 1.理解类的继承概念和类的继承规则。根据实际需要正确的运用类的继承。 2.理解类的多态概念，掌握子类对父类方法的重新定义，理解方法的匹配调 用原则。 二、实验内容 1.模拟编写程序，理解类的继承、多态、继承和多态规则。 2. 独立编程，实现类的继承和多态。 三、实验过程 （一）继承 （1）模拟编写程序，理解类的继承，继承规则。 请编码实现动物世界的继承关系： （1）动物（Animal）具有行为：吃（eat）、睡觉（sleep）。 （2）动物包括：兔子（Rabbit），老虎（Tiger）。 （3）这些动物吃的行为各不相同（兔子吃草，老虎吃肉）；但睡觉的行为是一致的。 请通过继承实现以上需求，并编写测试类AnimalTest进行测试。 1. 定义Animal类，代码如下： public class Animal { public void sleep(){ System.out.println("我正睡觉呢！"); }

public void eat(){} } 2. 定义Tiger类，代码如下： public class Tiger extends Animal { public void eat(){ System.out.println("我喜欢吃肉！"); } } 3. 定义Rabbit类，代码如下： public class Rabbit extends Animal { public void eat(){ System.out.println("我喜欢吃草和青菜！"); } } 4、定义AnimalTest类，代码如下： public class AnimalTest { public static void main(String[] args) { Tiger tiger = new Tiger(); tiger.sleep(); tiger.eat(); System.out.println(); Rabbit rabbit = new Rabbit();

对多态性和继承的理解

C#中的继承符合下列规则： 1、继承是可传递的。如果C从B中派生，B又从A中派生，那么C不仅继承了B中声明的成员，同样也继承了A中的成员。Object 类作为所有类的基类。 2、派生类应当是对基类的扩展。派生类可以添加新的成员，但不能除去已经继承的成员的定义。 3、构造函数和析构函数不能被继承。除此以外的其它成员，不论对它们定义了怎样的访问方式，都能被继承。基类中成员的访问方式 只能决定派生类能否访问它们。 4、派生类如果定义了与继承而来的成员同名的新成员，就可以覆盖已继承的成员。但这并不因为这派生类删除了这些成员，只是不能再 访问这些成员。 5、类可以定义虚方法、虚属性以及虚索引指示器，它的派生类能够重载这些成员，从而实现类可以展示出多态性。 6、派生类只能从一个类中继承，可以通过接吕实现多重继承。 多态性 在C#中，多态性的定义是：同一操作作用于不同的类的实例，不同的类将进行不同的解释，最后产生不同的执行结果。C#支持两种类型的多态性： ●编译时的多态性 编译时的多态性是通过重载来实现的。对于非虚的成员来说，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。 ●运行时的多态性 运行时的多态性就是指直到系统运行时，才根据实际情况决定实现何种操

作。C#中，运行时的多态性通过虚成员实现。 编译时的多态性为我们提供了运行速度快的特点，而运行时的多态性则带来了高度灵活和抽象的特点。 2、实现多态 多态性是类为方法（这些方法以相同的名称调用）提供不同实现方式的能力。多态性允许对类的某个方法进行调用而无需考虑该方法所提供的特定实现。可以用不同的方式实现组件中的多态性： ●接口多态性。 ●继承多态性。 ●通过抽象类实现的多态性。 接口多态性 多个类可实现相同的“接口”，而单个类可以实现一个或多个接口。接口本质上是类需要如何响应的定义。接口描述类需要实现的方法、属性和事件，以及每个成员需要接收和返回的参数类型，但将这些成员的特定实现留给实现类去完成。组件编程中的一项强大技术是能够在一个对象上实现多个接口。每个接口由一小部分紧密联系的方法、属性和事件组成。通过实现接口，组件可以为要求该接口的任何其他组件提供功能，而无需考虑其中所包含的特定功能。这使后续组件的版本得以包含不同的功能而不会干扰核心功能。其他开发人员最常使用的组件功能自然是组件类本身的成员。然而，包含大量成员的组件使用起来可能比较困难。可以考虑将组件的某些功能分解出来，作为私下实现的单独接口。 根据接口来定义功能的另一个好处是，可以通过定义和实现附加接口增量地将功能添加到组件中。优点包括：

自考Java语言程序设计(一)第五章以后课后习题及答案

自考Java语言程序设计（一）第五张课后习题及答案 自考Java语言程序设计（一）第五章类的继承课后习题 五、类的继承 l．什么是继承?什么是父类?什么是子类?继承的特性可给面向对象编程带来什么好处?什么是单重继承?什么是多重继承? 2．观察下面的程序片断，指出其中的父类和子类，以及父类和子类的各个域和方法。 class SuperClass { int data; voidsetData(intnewData) { data=newData~ } intgetData() { return data~ } } class SubClass extends SuperClass { int suhData; void setSubData(intnewData) { suhData=new Data; } intgetData() { return subData; } } 3．“子类的域和方法的数目一定大于等于父类的域和方法的数目”，这种说法是否正确?为什么? 4. 在Java程序中，通过类的定义只能实现单重继承() 5.下列哪些说法是正确的？ A、Java 语言只允许单一继承 B、Java 语言只允许实现一个接口 C、Java 语言不允许同时继承一个类并实现一个接口 D、Java 语言的单一继承使得代码更加可靠 6.Java中所有类都是类________的子类。

7.请写出下面程序的运行结果。 public class Test extends TT{ public void main(String args[]){ Test t = new Test("Tom"); } public Test(String s){ super(s); System.out.println("How do you do?"); } public Test(){ this("I am Tom"); } } www.Ｅhttps://www.doczj.com/doc/1c6574513.html, class TT{ public TT(){ System.out.println("What a pleasure!"); } public TT(String s){ this(); System.out.println("I am "+s); } } 结果：________ 8.父类的成员在子类中的访问权限由决定。 9.对象的使用包括引用对象的成员变量和方法。通过运算符就能实现对对象成员变量的访问和对象 10.Java是面向对象语言，对象是客观事物的，对象与之是一一对应的，它是很具体的概念。 参考答案： l．答：继承是面向对象程序设计中两个类之间的一种关系。当一个类获取另一个类中所有非私有的数据和操作的定义作为它自己的部分或全部成分时，就称这两个类之间具有继承关系。被继承的类称为父类或超类，继承了父类或超类的所有数据和操作的类称为子类。 面向对象程序设计中的继承，可使得程序结构更加清晰，降低了编码和维护的工作量。如果一个类只能有一个父类，则这种继承关系称为单重继承；如果一个类可以有多个父类，则这种继承关系称为多重继承。 2．答： 父类SuperClass 父类的域data来源：考试大的美女编辑们 父类的方法setData()，getData() 子类SubClass 子类的域data，subData 子类的方法setSubData()，setData()，getData()采集者退散 3．答：这种说法是错误的，因为子类不一定能继承父类的所有域和方法，它只能

继承与多态的习题

一：选择题 1. 下面有关析构函数的说法中，不正确的是( ) A．析构函数中不可包含Return语句 B．一个类中只能有一个析构函数 C．用户可定义有参析构函数 D．析构函数在对象被撤销时，被自动调用 2．派生类不可以访问基类的( ) A．Public成员B．Private成员 C．Protected成员D．Protected internel成员 3．有关sealed修饰符，描述正确的是( ) A．密封类可以被继承 B．abstract修饰符可以和sealed修饰符一起使用 C．密封类不能实例化 D．使用sealed修饰符可保证此类不能被派生 4．若想从派生类中访问基类的成员，可以使用( ) A．this关键字B．me关键字 C．base关键字D．override关键字 5．下面有关派生类的描述中，不正确的是( ) A．派生类可以继承基类的构造函数 B．派生类可以隐藏和重载基类的成员 C．派生类不能访问基类的私有成员 D．派生类只能有一个直接基类 6．C#中，继承具有( )，即A类派生B类，B类又派生C类，则C类会继承B类中的成员和A类中的成员。 A．传递性B．多态性C．单继承D．多继承 7．下面有关静态方法的描述中，错误的是( ) A．静态方法属于类，不属于实例 B．静态方法可以直接用类名调用 C．静态方法中，可以定义非静态的局部变量 D．静态方法中，可以访问实例方法 8．下面关于运算符重载的描述中，错误的是( ) A．重载的运算符仍然保持其原来的操作数个数、优先级和结合性不变 B．可以重载双目运算符，不可以重载单目运算符 C．运算符重载函数必须是public的 D．运算符重载函数必须是static的 9．下面对派生类和基类的关系的描述中，不正确的是( ) A．派生类的方法可以和基类的方法同名 B．派生类是对基类的进一步扩充 C．派生类也可作另一个派生类的基类 D．派生类继承基类的公有、保护和私有成员 10.下面关于虚方法的描述中，正确的是（） A．虚方法可以实现静态联编 B．在一个程序中，不能有同名的虚方法 C．虚方法必须是类的静态成员

JAVA基础 第4章继承与多态_练习题_200910

第4章继承与多态一．选择题 1、编译与运行以下两文件结果就是( D )。 //文件P1、java package MyPackage; class P1{ void afancymethod(){ System、out、println("What a fancy method"); } } //文件P2、java package YourPackage; import MyPackage、*; public class P2 extends P1{ public static void main(String argv[]){ P2 p2 = new P2(); p2、afancymethod(); } } A.两个均通过编译,P2运行时输出What a fancy method B.没一个通过编译 C.两个均通过编译,但P2运行时出错 D.P1 通过编译,但P2出现编译错误 2.下列程序运行的结果就是( A )。 package a; package b; public class D{ public static void main(String args[]) { System、out、println("^_^,今天心情不错！"); } } A.出现编译错误 B.^_^,今天心情不错！ C.通过编译,运行时出错 D.以上都不对 3.Java的核心类库中哪个包,Java系统能自动引入( B )。 A.java、io B.java、lang C.java、net D.java、util 4.下列程序运行结果就是( A )。 private class Base{ Base(){ int i = 100; System、out、println(i); }

实验8_继承和多态

实验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章继承与多态性习题参考答案 8.3 习题 8.3.1 选择题 题号 1 2 3 4 5 6 7 8 9 10 答案 C D A D A B C B D D 题号11 12 13 14 15 16 17 18 19 20 答案 D D A C B C C C A C 8.3.2 填空题 1．(1) a、b、c、x、y、z (2) b、y (3) c、z (4) a、x (5) b、c、x、y、z (6) b、y (7) y (8) b、c、z (9) a、x (10) b、c、x、y、z (11) y (12) y (13) z (14) a、b、c、x (15) b、c、x、y、z (16) y 2．私有 3．抽象 4．虚基 5．(1) 基类(2) 对象 6．(1) 静态(2) 编译(3) 虚函数 7．(1) 2 1 (2) 0 5 8．(1) 100 200 300 30 (2) 10 100 (3) 20 200 9．(1) 5 10 (2) end. (3) 20 10 10．(1) classA classB (2) end. (3) ~classB ~classA 11．(1) 10 (2) build B (3) build C (4) release A 12．(1) class B (2) class C (3) class D (4) 5 13．(1) 5 5 (2) 20 20 14．(1) 10 (2) 10 20 15．(1) 1 (2) 3 (3) 5 (4) 100 10 16．(1) B::f() (2) B::fun() (3) A::f() (4) B::fun() 17．(1) 姓名陈涛年薪6.8万元。(2) 姓名李原(3) 姓名李原月工资4000元18．(1) 110 (2) 2220 19．(1) protected 或public (2) Base1(s1),Base2(s2) 或Base2(s2),Base1(s1) (3) Base1::str (4) test.print() 20．(1) virtual void show()=0 (2) C(int,int,int) （注：参数可有任一名称） (3) b1(y) (4) &t 8.3.3 编程题 1．求长方形的面积和长方体的表面积、体积 #include class Rectangle{ protected: float L; // 长方形的长 float W; // 长方形的宽

java答案第五章

Java语言程序设计 第五章课后习题答案 1.什么是接口？接口起什么作用？接口与抽象类有何区别？ 答：Java中的接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为(功能)。 作用：接口是面向对象的一个重要机制，使用接口可以实现多态继承；接口中的所有方法都是抽象的，这些抽象方法由实现这一接口的不同类型来具体；接口还可以用来实现不同类之间的常量共享。 与抽象类不同的是：接口允许在看起来不相干的类之间定义共同行为。 2.试编程证明接口中的属性都隐含为static及final，所有的方法都为public。 //定义接口Shape2D interface Shape2D{ double Pi=3.14; double area(); } //Circle类继承接口Shape2D public class Circle implements Shape2D{ double radius; public Circle(double r){radius=r;} public double area(){return Pi*radius*radius;} } //A类（测试接口中隐含final的area()方法） public class A extends Shape2D{ public double area(); } //test5_2 public class test5_2{ public static void main(String args[]){ Circle c=new Circle(10); System.out.println("Pi=3.14圆的面积："+c.area()); SetPi b=new SetPi(3.00); System.out.println("改变Pi=3.00圆的面积："+c.area()); } } 运行结果：