第七章继续多态练习题
第七章继承多态
一、选择题：
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. 程序的运行结果是?（
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,5C: 5,4D: 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: 1B: 2C: 运行时异常.
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: 0B: 1C: 42D: 43E: 编译失败.
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 = 3C: 第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)，坦克战斗机和军舰都具有攻击的功能，抽象并定义这些类，通过抽象类和接口以及对应的实现类实现多态和这些类的测试
JAVA面向对象基础测试题,继承,封装,多态等测试题
JAVA面向对象基础测试题 提示：本题为第一阶段，JAVA面向对象基础部分练习题，包括对象，类，继承，封装，多态，接口，内部类等等，java核心基础，适合初学者对面向对象基础的知识进行测试，以便查漏补缺。 1. 程序执行的结果是：（）。 01 public class Point{ 02 int y = 7; 03 public void step(int y) { 04 y += y; 05 System.out.println(y); 06 } 07 public static void main(String[] args) { 08
Point p = new Point(); 09 p.step(10); 10 } 11 } A.14 B.20 C.10 D.17 正确答案：B解析： 2. 程序的执行结果是:（）。 01 public class Question { 02 private int num; 03 public static void main(String [] args){ 04 Question q = new Question();
05 q.num=13; 06 update(q); 07 System.out.println(q.num); 08 } 09 public static void update(Question q){ 10 q.num=9; 11 } 12 } A.13 B.9 C.0 D.4 正确答案：B解析： 3.
程序执行的结果是：（）。 01 public class Answer { 02 public static void main(String[] args) { 03 int score = 20; 04 Answer ans= new Answer(); 05 ans.add(score); 06 System.out.println(" main：score = " + score); 07 } 08 void add(int score) { 09 System.out.println(" add：score=" + score++); 10 } 11
如何体现封装、继承、多态 编程人员看看
如何体现封装、继承、 编程人员看看！ 如何体现封装、继承、多态 编程人员看看！！ ！ 什么事封装？ 1. 保护数据成员， 不让类以外的程序直接访问或 修改，只能通过提供的公共的接口访问==>数据封 装。 2. 方法的细节对用户是隐藏的，只要接口不变， 内容的修改不会影响到外部的调用者==>方法封装。 3. 当对象含有完整的属性和与之对应的方法时称为 封装。 4. 从对象外面不能直接访问对象的属性， 只能通 过和该属性对应的方法访问。 5. 对象的方法可以接收对象外面的消息。 比如： Class A { private int prop; puplic int getProp() { return prop; }
public void setProp(int prop) { this.prop = prop; } } 属性 prop 是 private 的，外界不能直接访问， 但是外界可以通过调用 getProp()和 setProp()的方 法， 给对象发消息，从而完成某种功能。 什么事多态？ 多态性的概念经常被说成事“一个接口，多种方 法”。这意味着可以为一组相关的动作作设计一个通 用 的接口。多态允许同一个接口被必于同一个类的多个 动作使用，这样就降低了程序的复杂性。再拿狗作比 喻， 一条狗的嗅觉是多态的。如果狗闻到猫的气味，它会 在吠叫并且追着它跑。如果狗闻到食物的气味，它将 分 泌唾液并向盛着食物的碗跑去。两种状况下同一种嗅 觉器官在工作，差别在于问到了什么气味，也就是有
两 种不同类型的数据作用于狗的鼻子!在 java 中，同一 个类中的 2 个或 2 个以上的方法可以有同一个名字， 只要 参数声明不同即可。在这种情况下，该方法就被称为 重载(Overload)，这个过程称为方法重载(Method overloading)。方法重载是 java 实现多态的一种方 式。 有两种方式可以实现多态：* 1. 继承(子类继承父类(包括 abstract class,interf ace ect)) 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 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. 运行结果是?（）
C 的封装性、继承性和多态性概念
C++的封装性、继承性和多态性概念 封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。例如，在抽象的基础上，我们可以将时钟的数据和功能封装起来，构成一个时钟类。按c++的语法，时钟类的声明如下：class Clock { public: //共有成员，外部借口void SetTime(int NewH,int NewM,int NewS); void ShowTime(); private: //私有成员，外部无法访问int Hour,Minute,Second; } 可以看到通过封装使一部分成员充当类与外部的接口，而将其他的成员隐蔽起来，这样就达到了对成员访问权限的合理控制，使不同类之间的相互影响减少到最低限度，进而增强数据的安全性和简化程序的编写工作。什么是多态（Polymorphisn）？按字面的意思就是“多种形状”。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为和一个或更多的他的子对象相等 的技术，赋值之后，>>>父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作<<<（摘自“Delphi4 编程技术内幕”）。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数（Virtual Function）实现的。好，接着是“虚函数”（或者是“虚方法”）。虚函数就是允许被其子类重新定
义的成员函数。而子类重新定义父类虚函数的做法，称为“覆盖”（override），或者称为“重写”。“继承”是面向对象软件技术当中的一个概念。如果一个类A继承自另一个类B，就把这个A称为"B的子类"，而把B称为"A的父类"。继承可以使得子类具有父类的各种属性和方法，而不需要再次编写相同的代码。在令子类继承父类的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类的原有属性和方法，使其获得与父类不同的功能。 ... 继承是指一个对象直接使用另一对象的属性和方法。事实上，我们遇到的很多实体都有继承的含义。例如，若把汽车看成一个实体，它可以分成多个子实体，如：卡车、公共汽车等。这些子实体都具有汽车的特性，因此，汽车是它们的"父亲"，而这些子实体则是汽车的"孩子"。19. 多态的作用？主要是两个：1. 隐藏实现细节，使得代码能够模块化；扩展代码模块，实现代码重用； 2. 接口重用：为了类在继承和派生的时候，保证使用家族中任一类的实例的某一属性时的正确调用。
第七章派生与继承2
第七章派生与继承2 /*7.4多继承与虚基类 7.4.1多继承中的二义性问题 解决方式 1<对象名>.<基类名>::<成员名> //数据成员 <对象名>.<基类名>::<成员名>(<参数名>) //成员函数 */ /*#include } } 上述代码在第一阶段Java的课程中经常见到，大致一看没什么问题，但是仔细分析过之后会发现：把年龄设置成1000合理吗？ 由于Person类的属性都是公有的（public），那也就意味着在Person类的外部，通过Person类的实例化对象可以对这些公有属性任意修改，这就使得我们无法对类的属性进行有效的保护和控制。这属于设计上的缺陷，那能不能避免这种情况呢？这就需要用到下面的封装了。 1.1.2现实生活中的封装 现实生活中封装的例子随处可见，例如药店里出售的胶囊类药品，我们只需要知道这个胶囊有什么疗效，怎么服用就行了，根本不用关心也不可能去操作胶囊的药物成分和生产工艺。再例如家家户户都用的电视机，我们只需要知道电视机能收看电视节目，知道怎么使用就行了，不用关心也不可能去搞清楚电视机内部都有哪些硬件以及是如何组装的。这些都是现实生活中封装的例子。 在刚才的两个例子中，我们可以认为药物成分是胶囊的属性，但是用户不需要也不可能去操作它。我们也可以认为内部硬件是电视机的属性，但是用户也不需要去操作它。这就是现实生活中封装的特征，程序中的封装与此类似。 1.1.3程序中的封装 封装就是：将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部的信息，而是通过该类所提供的方法来实现对内部信息的操作和访问。简而言之，封装就是将类的属性私有化，并提供公有方法访问私有属性的机制，我们看示例1.2。 示例1.2 public class Person{ //将属性使用private修饰，从而隐藏起来 private String name; private int age; public void sayHello() { System.out.print("你好！"); } } public class Test { public static void main(String[] args) { Person p=new Person(); https://www.wendangku.net/doc/d016624629.html,="杰克"; //编译报错 p.age=1000; //编译报错 p.sayHello(); } } 上机实验三：面向对象程序设计(继承、封装、多态) 类是面向对象程序设计的基础，是Java的核心和本质所在，在Java中，所有的语言元素都封装在类中。编写java程序的过程就是从现实世界中抽象出java可实现的类，并用合适的语句定义它们的过程，本节将学习类的应用，以及如何创建类的实例，通过类的继承更有效的组织程序结构，明确类之间的关系。掌握本节所讲的内容后，读者就可以使用面向对象技术编写java程序了。 接口是特殊的抽象类，只包含常量和方法的定义，而没有方法的实现，也就是说接口是方法定义和常量值的集合。 包是Java语言中有效管理类的一个机制。通过关键字package声明包语句，package语句作为Java源文件的第一条语句，指明该源文件定义的类所在的包。使用import语句可以引入包中的类。 一、实验目的 1)掌握类的定义和使用 2)掌握对象的声明和使用 3)了解构造函数的概念和使用 4)掌握类的继承关系和派生方法 5)掌握多态的概念与使用 6)掌握接口的定义和使用 7)掌握Java中包的应用 二、实验内容 1)类的声明 2)定义类成员变量以及成员方法 3)实例化类、创建类对象以及类方法的调用 4)类的继承 5)通过实例理解接口的定义 6)通过实例熟悉接口的应用 7)正确应用Java中包和import语句 三、实验步骤 1)类和类的实例化 一个类的实现包括两部分：类声明和类体。 （1）、类声明 [public][abstract][final] class className [extends superclassName] [implements interfaceNameList] {……} 期中修饰符[public][abstract][final]说明类的属性 className为类名 superclassName为父类的名字 第一章 抽象和封装 1.为什么使用面向对象 面向对象就是采用“现实模拟”的方法设计和开发程序。 面向对象实现了虚拟世界和现实世界的一致性，符合人们的思维习惯，使得客户和软件设计开发人员之间，软件设计开发人员内部交流更加顺畅，同时还带来了代码重用性高、可靠性高等优点，大大提高了软件尤其是大型软件的设计和开发效率 2.使用面向对象进行设计 面向对象设计的过程就是抽象的过程。 根据业务相关的属性和行为，忽略不必要的属性和行为，由现实世界中“对象”抽象出软件开发中的对象 第一步：发现类 第二步：发现类的属性 第三步：发现类的方法 类的基本结构，其主要由属性和行为组成，称为类的成员变量（或者成员属性）和成员方法，统称为类的成员（除此之外类的成员还包括构造方法，代码块等） 对象的创建： 通过够造方法来创建对象。 通过对象名.属性名的方式调用属性 通过对象名.方法名的方式调用方法 Static 可以用来修饰属性、方法和代码快。Static的变量属于这个类所有，即由这个 类创建的所有对象共同用一个 Static 变量。通常把Static修饰的属性和方法称为类 属性（类变量）、类方法。不使用Static修饰的属性和方法，属于单个对象，通常称为 实例属性（实例变量），实例方法。 类属性、类方法可以通过类名和对象名访问，实例属性、实例方法只能通过对象名访问。Final 可以用来修饰属性、方法和类。用final修饰的变量称为常量，其值固定不变。 构造方法的名字和类名相同，没有返回值类型。构造方法的作用主要就是在创建对象时 执行一些初始化操作，如给成员属性赋初值。 在没有给类提供任何构造方法时，系统会提供一个无参的方法体为空的默认构造方法。一旦提供了自定义构造方法，系统将不会再提供这个默认的构造方法，如果要使用，必须手动添加。 如果一个类中包含了两个或两个以上方法，他们的方法名相同，方法参数个数或参数类型不同，则称该方法被重载了，这个过程称为方法重载，成员方法和构造方法都可以进行重载。 常见错误： 在类中可以定义Static变量，在方法里是否可以定义Static变量？ 结论：在方法里不可以定义Static变量，也就是说类变量不能是局部变量。 给构造函数加上返回值类型会出现什么情况？ 结论：构造方法没有返回值类型，如果有，就不是构造方法，而是和构造方法同名的成员变量。 4．用封装优化类 封装：将类的状态信息隐藏在类内不能，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。 封装的具体步骤：修改属性的可见性来限制对属性的访问；为每个属性创建一对赋值方法（setter）和取值方法（getter），用于对这些属性的存取；在赋值方法中加入对属性的存取控制语句。 封装的好处主要有：隐藏类的实现细节；让使用者只能通过程序员规定的方法来访问数据；可以方便地加入存取控制语句，限制不合理操作。 封装时会用到多个权限控制符来修饰成员变量和方法，区别如下。 Private:成员变量和方法只能在类内被访问，具有类可见性 默认：成员变量和方法只能被同一个包里的类访问，具有包可见性。 Protected：可以被同一个包中的类访问，被同一个项目中不同包中的子类访问Public：可以被同一个项目中所有的类访问，具有项目可见性，这是最大的访问权限 第二章 继承 2.1 继承基础 1.在java中，继承通过extends关键字来实现， 2.父类又叫基类和超类。 20XX级java语言实验3指导(面向对象程序设计(继承、封装、多态)) 上机实验三：面向对象程序设计(继承、封装、多态) 类是面向对象程序设计的基础，是Java的核心和本质所在，在Java中，所有的语言元素都封装在类中。编写java 程序的过程就是从现实世界中抽象出java可实现的类，并用合适的语句定义它们的过程，本节将学习类的应用，以及如何创建类的实例，通过类的继承更有效的组织程序结构，明确类之间的关系。掌握本节所讲的内容后，读者就可以使用面向对象技术编写java程序了。 接口是特殊的抽象类，只包含常量和方法的定义，而没有方法的实现，也就是说接口是方法定义和常量值的集合。 包是Java语言中有效管理类的一个机制。通过关键字package声明包语句，package语句作为Java源文件的第一条语句，指明该源文件定义的类所在的包。使用import语句可以引入包中的类。 一、实验目的 1) 2) 3) 4) 5) 6) 7) 掌握类的定义和使用掌握对象的声明和使用 了解构造函数的概念和使用掌握类的继承关系和派生方法掌握多态的概念与使用掌握接口的定义和使用掌握 Java中包的应用 二、实验内容 1) 2) 3) 4) 5) 6) 7) 类的声明 定义类成员变量以及成员方法 实例化类、创建类对象以及类方法的调用类的继承 通过实例理解接口的定义通过实例熟悉接口的应用 正确应用Java中包和import语句 三、实验步骤 1) 类和类的实例化 一个类的实现包括两部分：类声明和类体。、类声明[public][abstract][final] class className [extends superclassName] [implements interfaceNameList] {……} 期中修饰符[public][abstract][final]说明类的属性className为类名 superclassName为父类的名字 interfaceNameList为类实现的接口列表、类体类体定义如下 class className { [public|protected|private] [static] [final] [transient] [volatile] Type variableName; //成员变量 习题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 实验五继承和多态 一．实验目的 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 数组，赋予数组不同的对象（比如第一个元素为圆锥、第二个元素圆柱、第三个球等，然后遍历这个数组，去求取每2016级java语言实验3指导(面向对象程序设计(继承、封装、多态))
Java封装、继承、多态
20XX级java语言实验3指导(面向对象程序设计(继承、封装、多态))
C++习题3(继承和多态)
实验七、继承和多态