一、问答题
1．子类可以有多个父类吗？
2．java.lang包中的Object类是所有其他类的祖先类吗？
3．如果子类和父类不在同一个包中，子类是否继承父类的友好成员？
4．子类怎样隐藏继承的成员变量？
5．子类重写方法的规则是怎样的？重写方法的目的是什么？
6．父类的final方法可以被子类重写吗？
7．什么类中可以有abstract方法？
8．对象的上转型对象有怎样的特点？
9．一个类的各个子类是怎样体现多态的？
10．面向抽象编程的目的和核心是什么？
二、选择题
1．下列哪个叙述是正确的？
2．下列哪个叙述是正确的？
3．下列程序中注释的哪两个代码（A，B，C，D）是错误的（无法通过编译）？
class Father {
private int money =12;
float height;
int seeMoney(){
return money ; //A
}
}
class Son extends Father {
int height;
int lookMoney() {
int m = seeMoney(); //B
return m;
}
}
class E {
public static void main(String args[]) {
Son erzi = new Son();
erzi.money = 300; //C
erzi.height = 1.78F; //D
}
}
4．假设C是B的子类，B是A的子类，cat是C类的一个对象，bird是B类的一个对象，下列哪个叙述是错误的？
5．下列程序中注释的哪个代码（A，B，C，D）是错误的（无法通过编译）？
class A {
static int m;
static void f(){
m = 20 ; //A
}
}
class B extends A {
void f() //B
{ m = 222 ; //C
}
}
class E {
public static void main(String args[]) {
A.f(); // D
}
}
6.下列代码中标注的（A,B,C,D）中，哪一个是错误的?
abstract class Takecare {
protected void speakHello() {} //A
public abstract static void cry(); //B
static int f(){ return 0 ;} //C
abstract float g(); //D
}
7．下列程序中注释的哪个代码（A，B，C，D）是错误的（无法通过编译）？
abstract class A {
abstract float getFloat (); //A
void f() //B
{ }
}
public class B extends A {
private float m = 1.0f; //C
private float getFloat () //D
{ return m;
}
}
8．将下列哪个代码（A，B，C，D）放入程序中标注的【代码】处将导致编译错误？
A. public float getNum(){return 4.0f;}
B. public void getNum(){ }
C. public void getNum(double d){ }
D. public double getNum(float d){return 4.0d;}
class A {
public float getNum() {
return 3.0f;
}
}
public class B extends A {
【代码】
}
9．对于下列代码，下列哪个叙述是正确的？
A. 程序提示编译错误（原因是A类没有不带参数的构造方法）
B. 编译无错误，【代码】输出结果是0。
C. 编译无错误，【代码】输出结果是1。
D. 编译无错误，【代码】输出结果是2。
class A {
public int i=0;
A(int m) {
i = 1;
}
}
public class B extends A {
B(int m) {
i = 2;
}
public static void main(String args[]){
B b = new B(100);
System.out.println(b.i); //【代码】
}
}
三、阅读程序
1．请说出E类中【代码1】，【代码2】的输出结果。
class A {
double f(double x,double y) {
return x+y;
}
}
class B extends A {
double f(int x,int y) {
return x*y;
}
}
public class E {
public static void main(String args[]) {
B b=new B();
System.out.println(b.f(3,5)); //【代码1】
System.out.println(b.f(3.0,5.0)); //【代码2】
}
}
2．说出下列B类中【代码1】，【代码2】的输出结果。
class A {
public int getNumber(int a) {
return a+1;
}
}
class B extends A {
public int getNumber (int a) {
return a+100;
}
public static void main (String args[]) {
A a =new A();
System.out.println(a.getNumber(10)); //【代码1】
a = new B();
System.out.println(a.getNumber(10)); //【代码2】
}
}
3．请说出E类中【代码1】~【代码4】的输出结果。
class A {
double f(double x,double y) {
return x+y;
}
static int g(int n) {
return n*n;
}
}
class B extends A {
double f(double x,double y) {
double m = super.f(x,y);
return m+x*y;
}
static int g(int n) {
int m = A.g(n);
return m+n;
}
}
public class E {
public static void main(String args[]) {
B b = new B();
System.out.println(b.f(10.0,8.0)); //【代码1】
System.out.println(b.g(3)); //【代码2】
A a = new B();
System.out.println(a.f(10.0,8.0)); //【代码3】
System.out.println(a.g(3)); //【代码4】
}
}
4．请说出E类中【代码1】~【代码3】的输出结果。
class A {
int m;
int getM() {
return m;
}
int seeM() {
return m;
}
}
class B extends A {
int m ;
int getM() {
return m+100;
}
}
public class E {
public static void main(String args[]) {
B b = new B();
b.m = 20;
System.out.println(b.getM()); //【代码1】
A a = b;
a.m = -100; // 上转型对象访问的是被隐藏的m
System.out.println(a.getM()); //【代码2】上转型对象调用的一定是子类重写的getM()方法
System.out.println(b.seeM()); //【代码3】子类继承的seeM()方法操作的m是被子类隐藏的m
}
}
四、编程题（参考例子13）
设计一个动物声音“模拟器”，希望模拟器可以模拟许多动物的叫声。要求如下：
Animal抽象类有2个抽象方法cry()和getAnimaName()，即要求各种具体的动物给出自己的叫声和种类名称。
该类有一个playSound(Animal animal)方法，该方法的参数是Animal类型。即参数animal可以调用Animal的子类重写的cry()方法播放具体动物的声音、调用子类重写的getAnimalName()方法显示动物种类的名称。
在主类Application的main方法中至少包含如下代码：
Simulator simulator = new Simulator();
simulator.playSound(new Dog());
simulator.playSound(new Cat());
图5.18是Simulator、Animal、Dog、Cat的UML图。
- 一、问答题
- 1．不可以。
- 2．是。
- 3．不继承。
- 4．声明与父类同名的成员变量。
- 5．子类重写的方法类型和父类的方法的类型一致或者是父类的方法的类型的子类型，重写的方法的名字、参数个数、参数的类型和父类的方法完全相同。重写方法的目的是隐藏继承的方法，子类通过方法的重写可以把父类的状态和行为改变为自身的状态和行为。
- 6．不可以。
- 7．abstract类。
- 8．上转型对象不能操作子类新增的成员变量，不能调用子类新增的方法。上转型对象可以访问子类继承或隐藏的成员变量，可以调用子类继承的方法或子类重写的实例方法。
- 9．通过重写方法。
- 10．面向抽象编程目的是为了应对用户需求的变化，核心是让类中每种可能的变化对应地交给抽象类的一个子类类去负责，从而让该类的设计者不去关心具体实现。
- 二、选择题
- 1．C。2．D。3．CD。4．D。5．B。6．B。7．D。8．B。9．A。
- 三、阅读程序
- 1．【代码1】：15.0。【代码2】：8.0。
- 2．【代码1】：11。【代码2】：11。
- 3．【代码1】：98.0。【代码2】：12。【代码3】：98.0。【代码4】：9。
- 4．【代码1】：120。【代码2】：120。【代码3】：-100。
- 四、编程题
- Animal.java
- public abstract class Animal {
- public abstract void cry();
- public abstract String getAnimalName();
- }
- Simulator.java
- public class Simulator {
- public void playSound(Animal animal) {
- System.out.print("现在播放"+animal.getAnimalName()+"类的声音:");
- animal.cry();
- }
- }
- Dog.java
- public class Dog extends Animal {
- public void cry() {
- System.out.println("汪汪...汪汪");
- }
- public String getAnimalName() {
- return "狗";
- }
- }
- Cat.java
- public class Cat extends Animal {
- public void cry() {
- System.out.println("喵喵...喵喵");
- }
- public String getAnimalName() {
- return "猫";
- }
- }
- Application.java
- public class Example5_13 {
- public static void main(String args[]) {
- Simulator simulator = new Simulator();
- simulator.playSound(new Dog());
- simulator.playSound(new Cat());
- }
- }
联系客服
