第七章继承多态练习题#(精选.)

第七章派生与继承1.单选题（1）．下列关于继承的描述中，错误的是（B）。

A．继承是重用性的重要机制B．C++语言支持单重继承和双重继承C．继承关系不是可逆的D．继承是面向对象程序设计语言的重要特性（2）．下列关于基类和派生类的描述中，错误的是（C）。

A．一个基类可以生成多个派生类B．基类中所有成员都是它的派生类的成员C．基类中成员访问权限继承到派生类中不变D．派生类中除了继承的基类成员还有自己的成员（3）．下列关于派生类的描述中，错误的是（D）。

A．派生类至少有一个基类B．一个派生类可以作另一个派生类的基类C．派生类的构造函数中应包含直接基类的构造函数D．派生类默认的继承方式是public（4）．派生类的对象可以直接访问的基类成员是（A）。

A．公有继承的公有成员B．保护继承的公有成员C．私有继承的公有成员D．公有继承的保护成员（5）．下列描述中，错误的是（D）。

A．基类的protected成员在public派生类中仍然是protected成员B．基类的private成员在public派生类中是不可访问的C．基类public成员在private派生类中是private成员D．基类public成员在protected派生类中仍是public成员（6）．派生类构造函数的成员初始化列表中，不能包含的初始化项是（B）。

A．基类的构造函数B．基类的子对象C．派生类的子对象D．派生类自身的数据成员（7）．下列关于子类型的描述中，错误的是（B）。

A．在公有继承下，派生类是基类的子类型B．如果类A是类B的子类型，则类B也是类A的子类型C．如果类A是类B的子类型，则类A的对象就是类B的对象D．在公有继承下，派生类对象可以初始化基类的对象引用（8）．下列关于多继承二义性的描述中，错误的是（D）。

A．一个派生类的多个基类中出现了同名成员时，派生类对同名成员的访问可能出现二义性B．一个派生类有多个基类，而这些基类又有一个共同的基类，派生类访问公共基类成员时，可能出现二义性C．解决二义性的方法是采用类名限定D．基类和派生类中同时出现同名成员时，会产生二义性2．多重继承与单一继承的区别是什么？答：派生类只有一个基类的称为单一继承。

第七章继承多态一、选择题：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 bD: hello from b E: hello from ahello from a hello from b4. 运行结果是:（）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. 运行结果是?（）A: 1 B: 2 C: 第8行编译失败. D: 第14行编译失败.8. 分析:public class ConstOver {public ConstOver(int x, int y, int z) {}}哪两个是对ConstOver 的构造方法的重载? ( )A:ConstOver() { } B:protected int ConstOver() { }C:private ConstOver(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) { }9. 运行结果是?（）A: 4,4 B: 4,5 C: 5,4 D: 5,5 E: 编译失败.10. 分析:public class X {public X aMethod() { return this;}}1) public class Y extends X {2)3) }在第2行可以插入哪两项? ( )A:public void aMethod() { } B:private void aMethod() { }C:public void aMethod(String s) { } D:private Y aMethod() { return null; } E:public X aMethod() { return new Y(); }11. 运行结果是?（）A: 4,4 B: 4,5 C: 5,4 D: 5,5 E: 编译失败.12. 以下哪两个重载了方法setVar()? ( )public class MethodOver {public void setVar(int a, int b, float c) {}}A:private void setVar(int a, float c, int b) { } B:public int setVar(int a, float c, int b) {return a;}C:protected void setVar(int a, int b, float c) { } D:public int setVar(int a, int b, float c) {return a;}E:protected float setVar(int a, int b, float c) {return c;}13. 分析:1) class BaseClass {2) private float x = 1.0f;3) protected void setVar(float f) { x = f; }4) }5) class SubClass extends BaseClass {6) private float x = 2.0f;7) // insert code here8) }在第7行插入哪两个覆盖了方法setVar()? ( )A:void setVar(float f) { x = f; } B:public void setVar(int f) { x = f; } C:public void setVar(float f) { x = f; } D:public double setVar(float f){ return f; }E:public final void setVar(float f) { x = f; } F:protected float setVar() { x = 3.0f; return 3.0f; }14. 运行结果是?( )A: 1 B: 2 C: 运行时异常. D: 第8行编译错误. E: 第14行编译错误.15. 分析:class A {protected int method1(int a, int b) { return 0; }}在A的子类中，以下哪两个方法是合法的? ( )A:public int method1(int a, int b) { return 0; } B:private int method1(int a, long b) { return 0; }C:private int method1(int a, int b) { return 0; } D:public short method1(int a, int b) { return 0; }E:static protected int method1(int a, int b) { return 0; }16. 分析:1) public abstract class Test {2) public abstract void methodA();3)4) public abstract void methodB()5) {6) System.out.println("Hello");7) }8) }哪两种改法，可以使程序通过编译? ( )A:给方法methodA()加方法体C:在Test的声明中去掉abstractB:用";"替换第5-7行D:在方法methodA()的声明中去掉abstract E: 在方法methodB()的声明中去掉abstract17. 运行结果是:（）1) abstract class AbstractIt {2) abstract float getFloat();3) }4) public class AbstractTest extends AbstractIt {5) private float f1 = 1.0f;6) private float getFloat() { return f1; }7) }A: 编译成功. B: 运行时异常. C: 第2行编译失败. D: 第6行编译失败.18. 在接口中哪两个方法的声明是合法的? ( )A:void method1(); B:public void method2(); C:static public void method5();D:protected void method3(); E:final public void method4();19. 分析:1) public interface Foo {2) int k = 4;3) }哪三项与第2行等价? ( )A:final int k = 4; B:public int k = 4; C:static int k = 4;D:abstract int k = 4; E:volatile int k = 4; F:protected int k = 4;20. 分析:interface Inter { }class A implements Inter { }class B extends A {B() {A[] arr = new A[10];boolean b1 = this instanceof Inter;boolean b2 = arr instanceof Object;System.out.println("b1 = " + b1 + ", b2 = " + b2);}}创建B的对象时会输出?( )A: 编译失败. B: b1 = true, b2 = true C: b1 = true, b2 = falseD: b1 = false, b2 = true E: b1 = false, b2 = false21. 哪一个能通过编译?（）A: new Animal().soundOff(); B: Lion l = Alpha1.get("meat eater");C: Elephant e = new Alpha1(); D: new Alpha1().get("veggie").soundOff();22. 分析:class Passenger { }class Engine { }interface TransportVehicle {void loadPassengers();}interface Helicopter extends TransportVehicle {int flyIt( String direction );}abstract class JetStream implements Helicopter { }哪种说法是正确的?（）A: TransportVehicle has a Passenger. B: 类Engine在类JetStream中.C: 接口TransportVehicle可以形成多态的基础.D: 继承JetStream的非抽象类可以随意声明方法loadPassengers().23. 哪三个是"is a" 关系? ( )A:public class X { } B:public interface Shape { }public class Y extends X { } public interface Rectangle extends Shape{ }C:public interface Color { } D:public class Species { }public class Shape { private Color color; } public class Animal { private Species species; }E:public class Person { } F:interface Component { }public class Employee { class Container implementsComponent {public Employee(Person person) { } private Component[] children;} }24. 运行结果是:（）public interface Test {int frood = 42;}class TestImpl implements Test {private static int frood;public static void main(String[] args) {System.out.println(++frood);}}A: 0 B: 1 C: 42 D: 43 E: 编译失败. F: 运行时异常.25. 运行结果是?（）A: 5 B: 10 C: 编译失败. D: 运行时异常.26. 运行结果是:（）1) public class Test {2) public static void main(String args[]) {3) class Foo {4) public int i = 3;5) }6) Object o = (Object)new Foo();7) Foo foo = (Foo)o;8) System.out.println("i = " + foo.i);9) }10) }A: i = 3 C: 第6行抛出ClassCastException异常.B: 编译失败. D: 第7行抛出ClassCastException异常.27. 分析:String s = "abcde";Object ob = (Object)s;if (ob.equals(s)) {System.out.println("AAAA");} else {System.out.println("BBBB");}if (s.equals(ob)) {System.out.println("CCCC");} else {System.out.println("DDDD");}输出哪两行? ( )A:AAAA B:BBBB C:CCCC D:DDDD二、简答题1. 简述类与类之间的关系2. 简述继承的基本概念及继承的过程3. 简述方法重写以及方法重载与方法重写的区别4. 简述super关键字的用法5. 简述重写equals方法的步骤6. 简述instanceof关键字的用法7. 简述接口和抽象类的区别8. 简述什么是多态三、编程题1. 设计一个学生类Student,包括的属性有姓名name，年龄age，学位degree。

一、单选题1、关于静态数据成员的描述不正确的是（）。

A.静态数据成员是所有对象共有的成员。

B.静态数据成员初始化时一定要在前面加修饰符static。

C.静态数据成员在内存中占有固定内存。

D.静态数据成员在类体外初始化。

正确答案：B2、假设person是一个类，p1是该类的一个对象，p2是指向p1的指针，getname是该类的一个成员函数，则以下不正确的表达是（）。

A.person.getname( );B.p1.getname( )C.p2->getname( )D.p1.person::getname( );正确答案：A3、下列静态数据成员的特性中，（）是错误的。

A.静态数据成员在类体外进行初始化B.说明静态数据成员时前边要加关键字static来修饰C.静态数据成员初始化时,要在静态数据成员名前加类名和作用域运算符D.静态数据成员不是所有对象所共有的成员正确答案：D4、关于常数据成员的说法不正确的是（）。

A.常数据成员通过构造函数的成员初始化列表进行初始化B.常数据成员的定义与一般常量的定义形式相同，但需定义在类体中C.常数据成员可以在定义时直接初始化D.常数据成员必须进行初始化,并且不能被更新正确答案：C5、对于类中定义的成员，其隐含访问权限为（）。

A.staticB.privateC.protectedD.public正确答案：B6、下列特性中不是面向对象程序设计语言所特有的是（）。

A.模板B.继承C.多态性D.数据封装正确答案：A7、下列对派生类的描述中，错误的是( )。

A.派生类中继承的基类成员的访问权限到派生类保持不变。

B.派生类至少有一个基类。

C.派生类的成员除了其自身的成员外，还包含了其基类的成员。

D.一个派生类可以作为另一个派生类的基类。

正确答案：A8、在公有继承中，派生类成员函数不可以访问( )。

A.基类中的保护成员B.基类中的公有成员C.基类中的私有成员D.派生类中的私有成员正确答案：C9、#include "iostream"using namespace std;class A{char c;public:A(char n){c=n;}~A(){cout<<c;};};class B:public A{char c;public:B(char n):A(n+1){c=n;}~B(){cout<<c;};};int main(){B b('X');b.~B();system("pause");return 0;}A.XYB.XC.YXD.Y正确答案：A10、假设在以下派生类的fun函数中调用了基类的fun函数，则空白处应填写（）class AA{public:void fun(){cout<<"aa fun called"<<endl;}};class BB:public AA{public:void fun(){_________________;cout<<"bb fun called"<<endl; }};A.AA.fun();B.fun();C.AA::fun();D.AA->fun();正确答案：C11、关于虚函数的描述中，（）是正确的。

练习八一、单项选择题（1）答：A 。

C++中若指定公有继承方式，基类中public成员在派生类中仍保持为public 成员，所以在派生类中可直接使用这些继承过来的成员。

这些成员可以通过派生类的对象访问。

（2）答：D。

派生类中继承的基类成员的访问权限到派生类保持不变的前提必须是公有继承，D错误。

（3）答：B。

构造函数、析构函数和友元函数是不能被派生类继承的。

（4）答：D。

在继承链中，构造函数的执行原则是：先执行基类的构造函数，再执行派生类的构造函数。

当一个派生类的对象使用完毕撤消时，析构函数的执行顺序正好与构造函数的执行顺序相反。

即：先执行派生类的析构函数，再执行基类的析构函数。

（5）答案：D。

派生类的对象占用的内存大小是其基类的数据成员占用的内存和派生类中新增成员占用的内存之和（包括基类的不可见成员）。

（6）答案：D。

A、B、C的叙述都正确。

当派生类和基类中出现同名函数不会产生二义性，支配规则会起作用。

（7）答案：B。

建立派生类的对象调用构造函数的初始化过程如下图所示：C++又规定，在一个成员初始化列表中出现对虚基类和非虚基类构造函数的调用，则虚基类的构造函数先于非虚基类的构造函数的执行。

二、填空题（1）答：【1】单继承【2】多继承（2）答：【1】隐式转换【2】强制类型转换（3）答案：【1】c_public【2】c_protected【3】a_public、a_protected、b_protected、b_public、c_private提示：基类中所有成员在派生类中的具体访问权限表如下所示B从A获得的都变为保护成员（a_public、a_protected）。

因此B中的成员有：公有型b_public，保护型a_public、a_protected、b_protected，私有型b_private。

B通过私有继承方式派生出C 时，B的公有型和保护型成员都变为C的私有成员。

三、程序题（1）答：【1】virtual public Furniture【2】virtual public Furniture【3】public Bed,public Sofa。

1、下列对基类和派生类关系的描述中，错误的是_________。

A)派生类是基类的具体化B)派生类是基类的子集C)派生类是基类定义的延续D）派生类是基类的组合2、继承具有_________ ，即当基类本身也是某一个类的派生类时，底层的派生类也会自动继承间接基类的成员。

A)规律性B)传递性C)重复性D)多样性3、下面_________的叙述不符合赋值兼容规则。

A)派生类的对象可以赋值给基类的对象B)基类的对象可以赋值给派生类的对象C)派生类的对象可以初始化基类的引用D)派生类的对象的地址可以赋值给指向基类的指针5、下面叙述错误的是_________。

A)派生类可以使用private派生B)对基类成员的访问必须是无二义性的C)基类成员的访问能力在派生类中维持不变D)赋值兼容规则也适用于多继承的组合6、下列说法中错误的是_________。

A)公有继承时基类中的public成员在派生类中仍是public的B)公有继承时基类中的private成员在派生类中仍是private的C)私有继承时基类中的public成员在派生类中是private的D)保护继承时基类中的public成员在派生类中是protected的7、C++的类有两种用法:一种是类的实例化，即生成类的对象，并参与系统的运行；另一种是通过_________派生出新的类。

A)复用B)继承C)封装D)引用8、下列关于虚基类的描述中，错误的是_________。

A)虚基类子对象的初始化由最派生类完成B)虚基类子对象的初始化次数与虚基类下面的派生类个数有关C)设置虚基类的目的是消除二义性D)带有虚基类的多层派生类构造函数的成员初始化列表中都要列出对虚基类构造函数的调用9、派生类的构造函数的成员初始化列表中，不能包含_________。

A)基类的构造函数B)派生类中子对象的初始化C)基类中子对象的初始化D)派生类中一般数据成员的初始化10、C++类体系中，不能被派生类继承的有_________。

习题3一、选择题1.在C++中，类与类之间的继承关系具有（ C ）A)自反性B)对称性C)传递性D)反对称性2.在公有继承的情况下，基类的成员（私有的除外）在派生类中的访问权限（ B ）A)受限制B)保持不变C)受保护D)不受保护3.按解释中的要求在下列程序划线处填入的正确语句是：（ C ）#include <iostream.h>class Base{public:void fun(){cout<<"Base::fun"<<endl；}}；class Derived:public Base{public：void fun(){ //在此空格处调用基类的函数fun()cout<<"Derived::fun"<<endl；}}；A)fun()；B)Base.fun()；C)Base::fun()；D)Base->fun()；4.在保护继承的情况下，基类的成员（私有的除外）在派生类中的访问权限（C ）页脚内容1A)受限制B)保持不变C)受保护D)不受保护5．在哪种派生方式中，派生类可以访问基类中的protected成员（B ）A)public和private B)public、protected和privateC)protected和private D)仅protected6.当一个派生类仅有protected继承一个基类时，基类中的所有公有成员成为派生类的（C）A) public成员B) private成员C) protected成员D) 友元7.不论派生类以何种方法继承基类，都不能使用基类的（B ）A) public成员B) private成员C) protected成员D) public成员和protected成员8下面叙述错误的是（S ）。

A)基类的protected成员在派生类中仍然是protected的B)基类的protected成员在public派生类中仍然是protected的C)基类的protected成员在private派生类中是private的D)基类的protected成员不能被派生类的对象访问9.下列说法中错误的是（S ）。

继承与多态习题继承与多态习题⼀.基本概念与基础知识⾃测题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）派生类对象只能访问基类中的（）。

A）公有继承的公有的成员B）公有继承的私有成员C）公有继承的保护成员D）私有继承的公有成员（2）下列对派生类的描述中，（）是错误的。

A）一个派生类可以作为另一个派生类的基类B）派生类至少有一个基类C）派生类的成员除了它自己的成员外，还包含了它的基类成员D）派生类中继承的基类成员的访问权限到派生类保持不变（3）C++类体系中，能被派生类继承的是（）。

A）构造函数B）虚函数C）析构函数D）友元函数（4）假设有如下定义，那么执行main()函数后下列四个语句输出的顺序是（）。

class CBase{public: CBase(){cout<<"Construct Base."<<endl;}public: ~CBase(){cout<<"DeConstruct Base."<<endl;}};class CDerived:public CBase{public: CDerived(){cout<<"Construct Derived."<<endl;}public: ~CDerived(){cout<<"DeConstruct Derived."<<endl;}};void main(){CDerived *obj=new CDerived;delete obj;system("pause");}①Construct Base. ②DeConstruct Base.③Construct Derived. ④DeConstruct Derived.A）①②③④B）①③②④C）③④①②D）①③④②（5）如果存在如下定义，那么main()函数输出的结果是（）。

1、请编码实现如下需求：(1)动物(Animal)分为：兔子(Rabbit)、老虎(Tigger)。

其中动物类(Animal)为抽象出来动物父类，有表示动物的重量weight、颜色color；动物的吃(eat())、睡(sleep())及抽象动物的游泳(swim())行为；以及相应的构造方法。

(2)兔子类(Rabbit)有一个特殊属性年龄age，特有的吃、睡行为；老虎类(Tigger)的特殊属性性别tiggerSex，特有的吃、睡及游泳行为。

(3)编写一个测试类AnimalTest，要求:对各种动物进行测试。

要依据不同的不同，进行相应的各种行为的测试。

(4)用UML工具，画出上述类的类图及类与类之间的关系。

class Animal {double weight;String color;Animal(double weight , String color) {this.weight = weight;this.color = color;}public String eat() {return "Eating...";}public String sleep() {return "Sleep...";}public String swim() {return "Swim...";}public String info(){return ("weight=" + weight + ",color=" + color );}}class Rabbit extends Animal{int age ;Rabbit(int age) {super(8,"白色");this.age = age;}public String eat() {return "Eating Radish.. ";}public String sleep() {return " Rabbit Sleep...";}public String swim() {return "Rabbit Swim...";}public String info(){return (()+ ",age=" + age);}}class Tigger extends Animal {String tiggerSex;Tigger(String tiggerSex) {super(88,"黄色");this.tiggerSex = tiggerSex;}public String eat() {return "Eating Meat... ";}public String sleep() {return " Tigger Sleep...";}public String swim() {return "Tigger Swim...";}public String info(){return (() + ",tiggerSex=" + tiggerSex );}}public class TestAnimal {public static void main(String [] args) {Rabbit rabbit = new Rabbit(9);Tigger tigger = new Tigger("男");/*rabbit.weight = 8;rabbit.color = "白色";tigger.weight = 88;tigger.color = "黄色";*/System.out.println(());System.out.println("rabbit.eat=" + rabbit.eat());System.out.println("rabbit.sleep=" + rabbit.sleep());System.out.println("rabbit.swim=" + rabbit.swim());System.out.println("==========================");System.out.println(());System.out.println("tigger.eat=" + tigger.eat());System.out.println("tigger.sleep=" + tigger.sleep());System.out.println("tigger.swim=" + tigger.swim());}}2、请编码实现如下需求：(1)乐器（Instrument）分为：钢琴(Piano)、小提琴(Violin)。

继承和多态习题1.构造方法的调用顺序测试：1)创建类A1，实现构造方法中输出“This is A”；2)创建A1的子类B1，实现构造方法中输出“This is B”；3)创建B1的子类C1，实现构造方法中输出“This is C”；4)创建测试类，实例化C1的一个对象cc，分析构造方法的执行顺序。

2.方法的覆盖测试1)创建类A2，实现一个方法test()，里面输出“This is A method”;2)创建类A2的子类B2，重新实现一个方法test()，里面输出“This is B method”;3)创建测试类，创建B2的对象bb，调用bb.test()，观察父类方法是否被覆盖？4)修改B2的test()方法，加上super.test()，输出变化么？3.属性的隐藏测试1)在上题的基础上，在类A2中，声明并初始化一个变量：String name="AAA";2)在B2中也声明并初始化一个变量：String name="BBB";3)在B2中，创建一个方法t()，在里面输出name；4)在测试类中，创建B2的对象bb，调用bb.t()，看看输出的名字是什么？5)再修改t()方法，加上输出，观察输出结果？4.继承的应用1)编写一个商品类Good；（使用以前做过的）2)编写商品类的子类牛奶，增加了表示会员价格的属性，覆盖父类的计算折扣的方法，要求能计算出会员和非会员折扣后各是多要钱。

3)编写测试类，初始化牛奶的价格为3元，会员价格为2.6元，折扣的百分比为0.8，测试子类的应用，输出折扣后的价格。

5.多态在工资系统中的应用。

1)定义一个类Employee作为超类2)Employee的子类有Boss（每星期发给他固定工资，而不计工作时间）、PieceWorker（按其生产的产品数发放工资）。

3)对所有雇员类型都使用earnings()方法完成其工资单的计算，但每个人挣的工资按他所属的雇员类计算，所有雇员类都是从超类Employee派出生的。

一：选择题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．虚方法必须是类的静态成员D．在派生类中重写虚方法，必须加上override修饰符二、判断：class A{private int x;public A(int i){x = i;}}class B : A{private int y;public B(){y = 0;}public B(int i):base(i){y = i;}public B(int i, int j) : base(i){y = j;}}三：程序填充：1. 以下程序的输出结果是：Base class…..Derived class…请在空白处填入适当内客，把程序补充完整。

第7章继承和接口设计一．选择题1．在C#中，一个类【】。

A) 可以继承多个类B) 可以实现多个接口C) 在一个程序中只能有一个子类D) 只能实现一个接口2．【】关键字用于在C#中从派生类中访问基类的成员。

A) new B) super C) this D) base3．在定义类时，若希望类的某个方法能够在派生类中进一步改进，以满足派生类的不同需要，则应将该方法声明为【】。

A) new B) public C) virtual D) override 4．在C#中，在派生类中对基类的虚方法进行重写，要求在派生类的声明中使用【】。

A) new B) public C) virtual D) override 5．已知类B是由类A继承而来，类A中有一个名为M的非虚方法，现在希望在类B中也定义一个名为M的方法，且两方法的参数个数和类型完全相同，若希望编译时不出现警告信息，则在类B中声明该方法时，应使用【】关键字。

A) static B) new C) override D) virtual6．假设类B继承了类A，下列说法错误的是【】。

A) 类B中的成员可以访问类A中的公有成员B) 类B中的成员可以访问类A中的保护成员C) 类B中的成员可以访问类A中的私有成员D) 类B中的成员可以访问类A中的静态成员7．关于多态，下列说法正确的是【】。

A) 多态实际上就是重载，它们本质上是以一样的B) 多态可以分为编译时多态和运行时多态。

前者的特点是在编译时就能确定要调用成员方法的哪个版本，后者则是在程序运行时才能确定要调用成员方法的哪个版本。

C) 编译时多态是在程序运行时才能确定要调用成员方法的哪个版本，而运行时多态在编译时就能确定要调用成员方法的哪个版本。

D) 多态和重载是两个完全不同的概念，前者是通过定义虚方法和重写虚方法来实现，后者是通过对同一函数名编写多个不同的实现代码来实现。

8．下列关于接口的说法，正确的是【】。

一、前言Java 是一种面向对象的编程语言，它支持继承、多态和接口等特性。

在使用Java进行编程时，对于继承、多态和接口的理解至关重要。

本文将围绕这三个主题，提出一些选择题，以帮助读者加深对Java面向对象编程的理解。

二、继承1. 继承是Java面向对象编程的重要特性之一。

在Java中，继承通过extends关键字来实现。

以下哪些说法是正确的？a) 子类继承了父类的所有成员变量和方法b) 子类可以继承多个父类c) Java不支持多重继承d) 父类可以继承子类e) 子类可以访问父类的private成员变量和方法2. 在使用继承时，有一些注意事项需要考虑。

以下哪些说法是正确的？a) 子类可以重写父类的private方法b) 子类的构造函数默认调用父类的无参构造函数c) 父类的private成员变量和方法不会被继承d) 子类可以访问父类的protected成员变量和方法e) 继承可以增强代码的重用性和扩展性三、多态1. 多态是Java面向对象编程的另一个重要特性。

在Java中，多态通过继承和重写来实现。

以下哪些说法是正确的？a) 多态可以提高代码的灵活性和可维护性b) 子类实现了父类的多态特性c) 多态可以使代码更易于扩展和修改d) 多态可以实现接口的统一访问2. 在使用多态时，有一些需要注意的地方。

以下哪些说法是正确的？a) 父类引用可以指向子类对象b) 子类引用可以指向父类对象c) 多态不适用于静态方法d) 引用类型决定了可以调用的方法e) 多态可以提高代码的可读性和可维护性四、接口1. 接口是Java面向对象编程的另一个重要特性，它定义了一组抽象方法。

以下哪些说法是正确的？a) 接口中的方法可以有方法体b) 类可以实现多个接口c) 接口可以继承多个接口d) 接口中的方法默认是public和abstracte) 接口可以包含成员变量2. 在使用接口时，有一些需要注意的地方。

以下哪些说法是正确的？a) 实现接口的类必须实现接口中的所有抽象方法b) 接口可以继承类c) 接口可以继承接口d) 实现多个接口时，如果有重名方法则需要在实现类中进行重写e) 接口可以包含静态方法和默认方法五、结语通过以上选择题，希望读者能够加深对Java面向对象编程中继承、多态和接口的理解。

一、继承的意义和应用1. 继承是面向对象编程中的重要概念，它允许一个类继承另一个类的属性和方法。

2. 在C++程序设计中，继承可以减少代码重复，提高代码的复用性和可维护性。

3. 通过继承，子类可以扩展或修改父类的行为，实现代码的灵活性和可扩展性。

二、继承的语法和实现1. 在C++中，使用关键字“class”定义一个类，通过“:”符号实现继承。

2. 派生类可以继承基类的公有成员和保护成员，但不能继承基类的私有成员。

3. 在派生类中，可以通过作用域解析运算符“::”访问基类的成员。

三、多态的概念和特点1. 多态是面向对象编程中的重要特性，它允许不同类的对象对同一消息作出不同的响应。

2. 多态可以增加程序的灵活性和可扩展性，提高代码的可读性和可维护性。

3. C++中实现多态的方式包括虚函数、纯虚函数和函数重载。

四、C++中实现多态的方法1. 虚函数是实现多态的关键，通过在基类中声明虚函数，在派生类中重写虚函数实现多态。

2. 纯虚函数是一种特殊的虚函数，它没有具体的实现，只是一个接口，必须在派生类中实现。

3. 函数重载允许在同一个作用域中定义多个同名函数，根据参数的不同实现不同的行为，也可以实现多态效果。

五、继承和多态的应用场景1. 继承和多态在实际的软件开发中有着广泛的应用,例如在设计图形界面控件时,可以使用继承和多态实现不同控件的共性和个性.2. 在游戏开发中，通过继承和多态可以实现不同角色的行为和动作。

3. 在企业应用中，可以通过继承和多态实现不同部门或员工的管理和操作。

六、C++程序设计中的继承和多态案例分析1. 通过一个实际的案例，演示如何使用C++实现继承和多态。

2. 分析案例中的设计思路和代码实现，介绍继承和多态在程序设计中的作用和效果。

3. 总结案例中的经验和教训，为读者提供实践经验和指导。

七、总结1. 继承和多态是C++程序设计中的重要内容，它可以提高代码的复用性和可维护性，增加程序的灵活性和可扩展性。

7．3 练习题解答1．什么是继承性?为什么说它是面向对象程序中的重要机制?答：继承是指一个对象是另一个对象的特例，则称这个对象继承了另一个对象。

继承是创建新类的一种手段，通过继承生成的新类中包含了被继承类中的所有成员，并且它还具有自己定义的成员。

继承性是面向对象程序设计方法中两大标志之一，即封装性和继承性。

继承性将提高可重用性，这是面向对象程序设计的重要特性。

继承性又是多态性的重要基础。

2．C十十中继承分为哪两类?继承方式又分哪3种?答：C十十语言支持两种继承：单继承和多继承。

有的面向对象程序设计语言只支持单继承，例如Java语言。

C十十语言中继承方式分为3种：公有继承(Public)、私有继承(private)和保护继承(protected)。

3．3种继承方式中各有什么特点?不同继承方式中派生类对基类成员的访问有何不同?答：继承方式有3种，它们区别在于不同继承方式使得基类成员在派生类中的访问权限不问。

具体讲来，公有继承方式时，基类中的公有和保护成员在派生类中仍是公有和保护成员；私有继承方式时，基类中的公有成员和保护成员在派生类中都为私有成员；保护继承方式时，基类中的公有成员和保护成员在派生类中都是保护成员。

3种方式中，基B类为A类的子类型，就称它们类型适应。

这时，B类对象就是A类对象。

可将B类对象直接赋值给A类对象。

反之不行。

另外，还可用B类对象初始化A类对象的引用，用B类对象的地址值赋给指向A类对象的指针。

9．多继承中，在哪些情况下会出现二义性?如何消除二义性?答：多继承中在下列两种情况下可能出现二义性：(1)访问不同基类中的相同成员可能出现二义性。

(2)访问共同基类中的成员时可能出现二义性。

·消除二义性的方法是适当地选择成员名限定的方法，这时要使用作用域运算符：：。

10．为什么要引入虚基类?带有虚基类的派生类的构造函数有什么特点?答：引入虚基类的目的是为了解公共基类可能造成的二义性。

作业要求：使学员掌握类之间继承的关系，掌握super关键字的作用，抽象类的使用，如何操作子类及父类等技术点。

1、给出一个类TestArray，具有堆栈的功能1) add(Object obj) 添加数据2) get(i) 读取数据3) clear() 清除所有数据4) getSize() 返回数据长度2、要求创建一个自定义的类继承TestArray类，增加以下功能3、增加add(Integer i)方法可以直接添加INT类型数据4、增加sort方法，对数据进行排序进行排序给出的TestArray类源码package com.test.action;public abstract class TestArray{private Object[] obj;public TestArray() {obj=new Object[1];}public TestArray(int i) {obj = new Object[i];}public boolean add(Object obj) {int j=0;if (obj==null)return false;for(int i=0;i<this.obj.length;i++) {if(this.obj[i]==null) {j+=1;this.obj[i]=obj;break;}}if(j==0) {Object[] obj2 = new Object[this.obj.length+1];for(int i=0;i<this.obj.length;i++) {obj2[i]=this.obj[i];}obj2[this.obj.length]=obj;this.obj=obj2;return true;}public int getSize() {return obj.length;}public Object get(int i) {return this.obj[i];}public void clear() {obj=new Object[1];}}效果显示：作业前提：第二部分\第二节课继承，封装，多态。

Python继承和多态是面向对象编程中的重要概念，可以帮助程序员编写更加灵活和可扩展的代码。

在本文中，我们将深入探讨Python继承和多态的基本概念，并通过编程题的形式来加深对这两个概念的理解。

1. Python继承的基本概念继承是面向对象编程中的重要概念，它允许一个类（称为子类）继承另一个类（称为父类）的属性和方法。

子类可以通过继承来获得父类的属性和方法，并且可以在此基础上添加新的属性和方法。

在Python 中，继承可以通过在子类定义时在类名后面加上父类的名称来实现。

例如：```pythonclass Animal:def __init__(self, name): = namedef make_sound(self):passclass Dog(Animal):def make_sound(self):print("汪汪汪")```在上面的例子中，我们定义了一个Animal类和一个Dog类，Dog类继承了Animal类的属性和方法，并且重新实现了make_sound方法。

2. Python多态的基本概念多态是面向对象编程中的另一个重要概念，它允许不同的子类对象对同一个方法做出不同的响应。

在Python中，多态可以通过方法的重写和方法的重载来实现。

方法的重写指的是子类重新实现了父类的方法，而方法的重载指的是在不同的子类中实现了同名的方法。

通过多态，我们可以编写出更加灵活和可扩展的代码。

3. 编程题接下来，我们将通过编程题的形式来加深对Python继承和多态的理解。

请编写一个程序，包含以下几个类：（1）Animal类，包含属性name和方法make_sound，方法make_sound打印出“动物发出叫声”的信息。

```pythonclass Animal:def __init__(self, name): = namedef make_sound(self):print("动物发出叫声")（2）Dog类，继承自Animal类，重载方法make_sound，方法make_sound打印出“汪汪汪”的信息。

下面是一个关于Java封装、继承和多态的作业题，可供学习和练习。

题目：学生管理系统
编写一个简单的Java程序，模拟一个学生管理系统。

系统应该包括以下类：
Student类：
属性：学生姓名、学号、年龄、成绩
方法：构造函数、获取学生信息的方法、设置学生信息的方法
Course类：
属性：课程名称、课程编号、授课老师
方法：构造函数、获取课程信息的方法、设置课程信息的方法
Teacher类：
属性：老师姓名、工号、教授课程
方法：构造函数、获取老师信息的方法、设置老师信息的方法
School类：
属性：学校名称、地址、联系电话
方法：构造函数、获取学校信息的方法、设置学校信息的方法
Main类：
创建几个学生对象、课程对象和老师对象，并分别设置它们的信息。

使用多态性质，创建一个列表或数组，存储不同的学生、课程和老师对象，然后通过循环遍历输出它们的信息。

要求：
使用封装的原则，将类的属性设置为私有，并提供公共的访问和修改方法。

使用继承的原则，确保子类可以继承父类的属性和方法。

使用多态的原则，通过父类的引用来操作子类对象。

这个作业题可以帮助学习者理解Java中的封装、继承和多态的概念，并将其应用到一个实际的项目中。

学生可以根据自己的理解和知识水平来扩展这个项目，添加更多的功能和类。