第七章继承多态
一、选择题：
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. 运行结果是?（）
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 here
8) }
在第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的声明中去掉abstract
B:用";"替换第5-7行D:在方法methodA()的声明中去掉abstract E: 在方法methodB()的声明中去掉abstract
17. 运行结果是:（）
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 = false
D: b1 = false, b2 = true E: b1 = false, b2 = false
21. 哪一个能通过编译?（）
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 implements
Component {
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。由学生类派生出本科生类Undergraduate和研究生类Graduate,本科生类包含的属性有专业specialty,研究生类包括的属性有研究方向studyDrection。每个类都有相关数据的输出方法。最后在一个测试类中对设计的类进行测试。
要求测试结果如下：
姓名：王军
年龄：23
学位：本科
专业：工业自动化
姓名：刘君
年龄：27
学位：硕士
研究方向：网络技术
2. 定义一组交通工具类，包括汽车类（AutoMobile）、飞机类(Plane)、船类(Ship)，其中汽车类有坦克(Tank)、卡车(Truck)、小汽车(Car)，飞机子类有客机(AirLiner)、战斗机(FighterPlane)，船类有子类游艇(Yacht)、军舰(WarShip)，坦克战斗机和军舰都具有攻击的功能，抽象并定义这些类，通过抽象类和接口以及对应的实现类实现多态和这些类的测试
继承与多态习题 一.基本概念与基础知识自测题 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 关键字只对紧随其后的基类名起作用。
第五章类与继承作业一 一、填空选择题 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;
第七章继承多态 一、选择题： 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. 运行结果是?（）
第七章派生与继承2 /*7.4多继承与虚基类 7.4.1多继承中的二义性问题 解决方式 1<对象名>.<基类名>::<成员名> //数据成员 <对象名>.<基类名>::<成员名>(<参数名>) //成员函数 */ /*#include 第七章继承和多态 1.继承的作用： 它是面向对象的三大特征之一，可以解决编程代码冗余的问题，是实现代码重用的重要手段之一。继承是软件可重用性的一种表现，新类可以在不增加自身代码的情况下，通过从现有的类中继承其属性和方法，来充实自身内容，这种表现或行为就称为继承。这个时候新类称为子类，现有的类称为父类。它最基本的作用就是：使得代码可重用，增加软件的可扩充性。 2.继承的语法： [访问修饰符] class 3.多重继承关系的初始化顺序： 父类属性>>父类构造方法>>子类属性>>子类构造方法。 4.实例化子类对象： A.创建该类的对象。 B.创建该类的子类的对象。 C.子类在实例化时，会首先执行父类的构造方法，然后才执行子类的构造方法。 5.子类继承父类时，构造方法的调用规则如下： a.如果子类的构造方法中没有通过super显式调用父类的有参构造方法，也没有通过this显式调用自身的其他构造方法，则系统默认先调用父类的无参构造方法，在这种情况下是否写入super语句，效果是一样的。 b.如果子类的构造方法中通过super显式调用父类的有参构造方法，那么将执行父类相应的构造方法，而不执行父类的无参构造方法。 c.如果子类的构造方法中通过this显式调用自身的其他构造 第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); } 习题3 一、选择题 1.在C++中，类与类之间的继承关系具有（ C ） A)自反性B)对称性C)传递性D)反对称性 2.在公有继承的情况下，基类的成员（私有的除外）在派生类中的访问权限（ B ） A)受限制B)保持不变C)受保护D)不受保护 3.按解释中的要求在下列程序划线处填入的正确语句是：（ C ） #include 有公有成员成为派生类的（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 ）。 A) 保护继承时基类中的public成员在派生类中仍是public 的 B)公有继承时基类中的private成员在派生类中仍是private 的 C)私有继承时基类中的public成员在派生类中是private的 D)保护继承时基类中的public成员在派生类中是protected 的 10下面叙述错误的是（C）。 A)派生类可以使用private派生 B)对基类成员的访问必须是无二义性的 C)基类成员的访问能力在派生类中维持不变 D)赋值兼容规则也适用于多继承的组合 11派生类的构造函数的成员初始化列表中，不能包含（C ）。 A)基类的构造函数B)派生类中子对象的初始化 C)基类中子对象的初始化D)派生类中一般数据成员的初始化 12.下列虚基类的声明中，正确的是：（ B ） A)class virtual B: public A B)class B: virtual public A 继承与多态性习题参考答案 ————————————————————————————————作者：————————————————————————————————日期： 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 实验五继承和多态 一．实验目的 1．理解继承的含义，掌握派生类的定义方法和实现； 2．理解公有继承下基类成员对派生类成员和派生类对象的可见性，能正确地访问继承层次中的各种类成员； 3．理解保护成员在继承中的作用，能够在适当的时候选择使用保护成员以便派生类成员可以访问基类的部分非公开的成员；正确使用base关键字； 4．理解虚函数在类的继承层次中的作用，虚函数的引入对程序运行时的影响，能够对使用虚函数的简单程序写出程序结果。 二、实验内容 1．编写一个程序计算出球、圆柱和圆锥的表面积和体积。 要求： （1）定义一个基类圆，至少含有一个数据成员——半径；提供方法来计算其面积并输出其信息； （2）定义基类的派生类球、圆柱、圆锥，根据不同的形状为其添加必须的数据成员（如定义圆柱必须额外给出圆柱的高），并添加或改写其方法成 员，提供各形状求表面积和体积的成员函数，并能正确输出该类对象实 例的信息。 （3）定义主函数，求球、圆柱、圆锥的和体积并输出结果信息。 注意：派生类覆盖基类的同名方法时，如果不是虚方法，需要在前面加关键字new,否则会有警告信息。 public class Circle { private double radius; public Circle () { ……} public Circle (double radiusValue){ this.radius = radiusValue; } public double Radius { ……} public virtual double CircumFerence()//计算周长 { ……} public virtual double Area()//基类中的面积计算方法 { ……} public override string ToString() { return "圆半径＝"+radius; } } public class Cylinder : Circle//圆柱继承自圆类 { private double height; public Cylinder() { } public Cylinder(double radiusValue, double heightValue) :base(。。。) { this. height = heightValue; } public override double Area() { … } 2．编写测试用例，对一组不同形状的物体调用其面积和体积的计算，并输出其结果。 提示：在Main方法中定义一个Circle 数组，赋予数组不同的对象（比如第一个元素为圆锥、第二个元素圆柱、第三个球等，然后遍历这个数组，去求取每 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()); } } 运行结果： 答案： 一、单项选择题 1．C 2．D 3．A 4．D 5．C 6．B 7．A 8．B 9．A 10．D 二、简答题 1． 面向对象编程的三大特征：封装、继承和多态。封装：通过设置访问权限等方式封装了内部实现细节，使用者只需要知道外部接口。继承：子类可以继承父类的成员，又可以新增自己独有的成员，还可以覆盖父类的成员。多态：同名方法可以具有不同的行为，Java中有两种意义的多态：重载和重写。 2． 万物皆是对象，对象都有属性和行为。属性是对象所拥有的状态、数据，是静态的特征；行为是对象所拥有的功能、对数据的操作，是动态的特征，可能会影响到属性。 类封装了一类对象共有的属性和行为，是对具有相同属性和行为的对象的抽象。类是创建对象的模板，对象是类的具体实例。 3． （1）定义在类体内、方法外的变量称为成员变量。定义在方法体内部的变量，以及方法的形式参数，是方法所临时使用的变量，称为局部变量。 （2）成员变量在整个类体中都有效。而局部变量的有效范围仅限于定义它的方法体内，具体说明如下：①方法的形式参数：在整个方法体内有效；②方法体内独立定义的变量：在方法体中该变量定义之后的语句中有效；③选择、循环等语句块内定义的变量：只在语句块的{ }内有效。 （3）如果定义的成员变量没赋值，则系统为其提供缺省的初始值。所以成员变量定义后就有了确定的值，就可以使用。而方法的局部变量必须自行定义而且赋值后才能使用。（4）类成员变量在程序加载进内存时即开辟空间，实例成员变量在创建对象时开辟空间。局部变量只在方法调用时开辟空间，方法执行完毕后空间随即释放。 4． 多个方法名字相同，但参数个数或者类型不同，称为方法重载。方法返回值的类型和参数的名字不参与比较，方法重载是多态的一种体现。当调用方法时，根据传入的实参个数和类型，可以区分出调用的是哪一个方法。 5． 构造方法与所在类的类名完全相同，构造方法没有返回值类型，也不用void修饰。构造方法可以重载，一个类中可以定义多个构造方法。每个类中至少都有一个构造方法，如果未定义构造方法，系统会自动为该类生成一个缺省的没有参数的构造方法，如果类中定义了构造方法，就不再提供其他构造方法。 构造方法用new调用来创建对象，一般在构造方法中初始化成员变量。构造方法不能用static修饰。 三.编程题 1. classVecter3: def__init__(self,x=0,y=0,z=0): self.X=x self.Y=y 第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．https://www.doczj.com/doc/d82705285.html,ng C．https://www.doczj.com/doc/d82705285.html, D．java.util 4．下列程序运行结果是（ A ）。 private class Base{ Base(){ int i = 100; System.out.println(i); } 第5章继承与多态 本章讨论面向对象程序设计另外两个最重要的特点：继承和多态。 继承是面向对象程序设计方法中实现软件重用的一种重要手段，通过继承可以更有效地组织程序结构，明确类之间的关系，并充分利用已有的类来创建新类，通过继承可以实现代码的重用，以完成更复杂的设计、开发。 多态则可以统一多个相关类的对外接口，并在运行时根据不同的情况执行不同的操作，提高类的抽象度和灵活性。 5.1 子类、父类与继承机制 5.1.1 继承的概念 在类的定义过程中，继承是一种由已有的类创建新类的机制。继承而得到的类为子类，被继承的类为父类，父类包括所有直接或间接被继承的类。 在类的声明中加入extends子句就可以创建一个类的子类： class SubClass extends SuperClass {……} Java中不通过extends关键字支持多重继承，即extends之后只能有唯一的父类。如果缺省extends子句，则该类为https://www.doczj.com/doc/d82705285.html,ng.Object的子类。子类可以继承父类中访问权限设定为public、protected和包可访问的成员变量和方法，但是不能继承访问权限为private的成员变量和方法。 一个父类可以同时拥有多个子类，而每一个子类则只能有唯一的父类。子类是对公共域和方法在功能、内涵方面的扩展和延伸。 父类、子类间的关系具有： 共享性即子类可以共享父类的公共域和方法。 差异性即子类和父类一定会存在某些差异，否则就应该是同一个类。 层次性即由Java规定的单继承性，每个类都处于继承关系中的某一个层面。 5.1.2 类的层次 Java语言中类的是有严格的层次结构的。 除Object类之外，每个类都继承惟一的父类。这种继承性性质使得类的层次结构形成了如图所示的一种树状结构。 Object类定义和实现了Java系统所需要的众多类的共同行为，它是所有类的父类，也即这个树状结构中的根类，所有的类都是由这个类继承、扩充而来的，这个Object类定义在https://www.doczj.com/doc/d82705285.html,ng包中。 5.2 继承的实现 5.2.1 子类的定义 定义一个子类，即在定义一个类的时候加上extends关键字，并在之后带上其父类名，其一般格式为：[类的修饰符] class <子类名> extends <父类名>{ <域定义>; <方法定义>; } 这和前面定义类的格式并没有什么区别，只是在定义子类时“extends <父类名>”不再是可选项。 面向对象的三大特性封装继承多态 知识点预览 封装的概念 继承的概念 访问修饰符 方法的覆盖（Override） super关键字 多态的概念 强制类型转换与instanceof关键字 封装的概念 1. 什么是封装 通过边界将内部组成部分与外部分开 2. 封装的好处 a) 提高一个物体内部组成部分的安全性 b) 向外部屏蔽物体内部组成部分的差异 私有访问修饰符private 2个方法获得设置 3. 封装的内容 a) 属性----->必须 b) 方法根据需要封装 c) 方法声明公开方法实现封装 ------->思想 继承的概念 1. 什么是继承 2. 继承的语法 a) extends关键字; b) 继承的好处：提高代码的复用性 3. 子类对象的扩展 4. Java语言中继承的特点 a) Java语言中继承是单继承（最多有一个直接父类） b) Java中单继承的好处 几何拓扑：树状结构较简单易于实现5. 继承关系在内存中的表现形式 JVM开辟连续的存储空间（父类、子类） 6. 对象的创建过程\ new Dog(); a) 分配空间（父类对象空间子类对象空间） b) 初始化属性 递归的构造父类对象 调用构造方法 c) 初始化属性 d) 调用构造方法 Java中的访问修饰符 1. 什么是Java中的访问修饰符式 private public default protected 2. Java中的访问修饰符 方法的覆盖（Override） 1. 什么是方法的覆盖 子类对从父类继承的方法重新实现 2. 方法覆盖的要求 a) 子类覆盖方法的访问修饰符范围必须大于或者等于父类对应方法的访问修饰符范围 b) 子类覆盖方法的返回值类型必须和父类方法一致 c) 覆盖方法的参数必须和父类方法一致 super关键字 1. super代表父类对象 a) super.属性 子类、父类出现同名，子类中访问父类属性 b) super(); 在付了构造方法中调用父类构造方法 2.super()总结 a) 每一个子类的构造方法没有显示调用super()，系统都会提供一个默认的super();（子类编译完后编译器默认加上super()，调用无参构造） b) super()书写在第一行; c) 可以在父类构造方法红枣年糕显示调用super()实现对特定父类构造方法的调用。 3. super思考题 TestSuper4 [java]view plaincopy 第7章继承和接口设计 一．选择题 1．在C#中，一个类【】。 A) 可以继承多个类B) 可以实现多个接口 C) 在一个程序中只能有一个子类D) 只能实现一个接口 2．【】关键字用于在C#中从派生类中访问基类的成员。 A) new B) super C) this D) base 3．在定义类时，若希望类的某个方法能够在派生类中进一步改进，以满足派生类的不同需要，则应将该方法声明为【】。 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) virtual 6．假设类B继承了类A，下列说法错误的是【】。 A) 类B中的成员可以访问类A中的公有成员 B) 类B中的成员可以访问类A中的保护成员 C) 类B中的成员可以访问类A中的私有成员 D) 类B中的成员可以访问类A中的静态成员 7．关于多态，下列说法正确的是【】。 A) 多态实际上就是重载，它们本质上是以一样的 B) 多态可以分为编译时多态和运行时多态。前者的特点是在编译时就能确定要调用成 员方法的哪个版本，后者则是在程序运行时才能确定要调用成员方法的哪个版本。 C) 编译时多态是在程序运行时才能确定要调用成员方法的哪个版本，而运行时多态在 编译时就能确定要调用成员方法的哪个版本。 D) 多态和重载是两个完全不同的概念，前者是通过定义虚方法和重写虚方法来实现， 后者是通过对同一函数名编写多个不同的实现代码来实现。 8．下列关于接口的说法，正确的是【】。 A) 接口中定义的方法都必须是虚方法 B) 接口中定义的方法可以编写其实现代码 C) 继承接口的类可提供被继承接口中部分成员的实现代码 D) 接口中的所有方法都必须在其派生类中得到实现。 9．下列关于虚方法的描述中，正确的是【】。 A) 虚方法能在程序执行时动态确定要调用的方法，因此比非虚方法更灵活 B) 在定义虚方法时，基类和派生类的方法定义语句中都要带上virtual修饰符 C) 在重写基类的虚方法时，为消除隐藏基类成员的警告，需要带上new修饰符 D) 在重写基类的虚方法时，需要同时带上virtual和override修饰符 10．在C#中，以下关于抽象类的叙述中错误的是【】。 A) 抽象类可以包含抽象方法B) 含有抽象方法的类一定是抽象类 C) 抽象类不能被实例化D) 抽象类可以是密封类 11．在C#中，以下关于抽象类和接口的叙述中正确的是【】。2015.6.17--java第七章继承和多态章总结
JAVA基础 第4章继承与多态_练习题_200910
C++习题3(继承和多态)
继承与多态性习题参考答案
实验七、继承和多态
java答案第五章
第五章 习题答案
JAVA基础第章继承与多态练习题
第5章继承与多态
《Java知识点总结系列》第七章——封装、继承、多态篇
第7章 继承和接口设计 习题
相关主题
文本预览