5.4 精选习题
一、单项选择题
1．（*）下列程序运行的结果是（ ）。
abstract class A {
void f() {
System.out.print("good");
}
}
class B extends A {
public voidf() {
System.out.print("bad");
}
publicstatic void main(String[] args) {
A b = newB();
b.f();
}
}
A．good B．bad
C．编译错误 D．以上都不对
2．下列哪个类声明是正确的？（ ）
A．abstract finalclass Plant { }
B．abstractprivate Sea() { }
C．protectedprivate number;
D．public abstractclass Car { }
3．下面的代码中正确的是（ ）。
A. class Example {
abstract void g();
}
B. interface Example {
void g() {
System.out.print("hello");
}
}
C. abstract class Example {
abstract voidg() {
System.out.print("hello");
}
}
D. abstract class Example {
void g() {
System.out.print("hello");
}
}
4．以下关于abstract的说法，正确的是（ ）。
A．abstract只能修饰类
B．abstract只能修饰方法
C．abstract类中必须有abstract方法
D．abstarct方法所在的类必须用abstract修饰
5．下列说法正确的是（ ）。
A．final 可修饰类、属性、方法
B．abstract可修饰类、属性、方法
C．定义抽象方法需有方法的返回类型、名称、参数列表和方法体
D．用final修饰的变量，在程序中可对这个变量的值进行更改
6．下列关于修饰符混用的说法错误的是（ ）。
A．abstract不能与final同时修饰一个类
B．接口中不可以有private的成员
C．abstract方法必须在abstract类或接口中
D．static方法中能直接处理非static的属性
7．（*）抽象类A和抽象类Test的定义如下：
abstract class A {
abstract int getInfo() {
}
}
public class Test extends A {
private int a = 0;
public int getInfo() {
return a;
}
public static void main(String args[]) {
Test b= new Test();
System.out.println(b.getInfo());
}
}
关于上述代码说明正确的是（ ）。
A．输出结果为0
B．通过编译但没有输出任何结果
C．第5行不能通过编译
D．程序第2行不能通过编译
8．下列有关抽象类与接口的叙述中正确的是（ ）。
A．抽象类中必须有抽象方法，接口中也必须有抽象方法
B．抽象类中可以有非抽象方法，接口中也可以有非抽象方法
C．含有抽象方法的类必须是抽象类，接口中的方法必须是抽象方法
D．抽象类中的变量定义时必须初始化，而接口中不是
9．下列叙述正确的是（ ）。
A．抽象类可以定义为final类，但抽象方法不可以定义为final方法
B．一个类实现了一个接口，那么这个类必须实现该接口的所有方法
C．类可以继承另一个类，但接口不可以继承另一个接口
D．一个类只可以继承另一个类，但可以实现多个接口
10．使用interface声明一个接口时，只可以使用哪个修饰符修饰该接口？（ ）
A．private B．public
C．protected D．static
11．关于接口的定义和实现，以下描述正确的是（ ）。
A．接口定义的方法只有定义没有实现
B．接口定义中的变量都必须写明final和static
C．如果一个接口由多个类来实现，则这些类在实现该接口中的方法时采用相同代码
D．如果一个类实现接口，则必须实现该接口中的所有方法，但方法未必声明为public
12．下列关于接口的描述中说法正确的是（ ）。
A．接口的实质是一种特殊的抽象类，里面只包含常量和抽象方法
B．一个类最多只能有一个父类，一个接口最多只能有一个父接口
C．一个类最多只能有一个父类，一个类最多只能实现一个接口
D．接口的访问权限分四种：公有、私有、友好、受保护的
13．（*）如果A和B是接口的名字，非抽象类C实现了接口A，则下面的代码中正确的是（ ）。
A．A a = newA();
B．A a = newC();
C．class Dimplement A & B { }
D．class Dextends A { }
14．下列关于接口的描述中说法错误的是（ ）。
A．类所实现的接口中的方法和常量，都可以通过类的对象来调用
B．即便父类实现了某个接口，其子类也必须再次实现该接口，才能继承该接口中的常量和方法
C．当一个类实现一个接口时，可以选择只实现接口中的部分抽象方法
D．接口之间可以通过关键词extends定义继承关系，类和接口之间通过关键词implements定义实现关系
15．关于类继承的说法，正确的是（ ）。
A．Java 类允许多重继承
B．Java接口允许多重继承
C．接口和类都允许多重继承
D．接口和类都不允许多重继承
16．（*）以下类或者接口定义中正确的是（ ）。
A．publicclass A {
privateint x;
publicint getX() {
returnx;
}
}
B．publicabstract class A {
private int x;
publicabstract int getX() {
returnx;
}
publicabstract int aMethod();
}
C．publicclass a {
private int x;
public abstract int getX();
}
D．publicinterface interfaceA {
private int x;
public int getX() {
return x;
}
}
17．下面哪个类实现了接口Usable?（ ）
interface Usable {
int eat(int data);
}
A．class Human implements Usable{
int use(int a) {
return 1;
}
}
B．class Human extends Usable {
public int use(int a) {
return 1;
}
}
C．class Human implements Usable{
public int use(int a) {
return 1;
}
}
D．class Human implements Usable{
public int use() {
return 1;
}
}
18．public interface Flyable {
float hight = 10;
}
下面哪一项与以上接口中的第二行不等价？（ ）
A．final float hight = 10;
B．private float hight = 10;
C．static float hight =10;
D．public float hight = 10;
19．下列程序运行的结果是（ ）。
interfaceInterfaceA {
int MAX = 10;
}
class ClassAimplements InterfaceA {
int a = 1;
}
class ClassBextends ClassA {
int b = 2;
}
public class E {
public static void main(String[] args) {
ClassB b = new ClassB();
System.out.print(b. MAX);
System.out.print(" " +ClassB.MAX);
System.out.print(" " +ClassA.MAX);
System.out.print(" " +InterfaceA.MAX);
}
}
A．编译错误：MAX在类ClassB没有定义
B．编译错误：MAX不能通过对象名b来访问
C．编译错误：MAX不能通过接口名InterfaceA来访问
D．10 10 10 10
20．（*）下列程序运行的结果是（ ）。
interfaceInterfaceA {
int MAX = 10;
void f();
}
interfaceInterfaceB extends InterfaceA {
void g();
}
class ClassAimplements InterfaceB {
public void g() {
System.out.print("I LoveJava");
}
}
public class E {
public static void main(String[] args) {
ClassA a = new ClassA();
a.g();
}
}
A．I Love Java
B．编译错误：ClassA 没有实现接口方法f
C．编译错误：InterfaceB不能继承InterfaceA
D．以上都不对
21．（*）下列程序运行的结果是（ ）。
interfaceInterfaceA {
String S = "good ";
void f();
}
abstract classClassA {
abstract void g();
}
class ClassBextends ClassA implements InterfaceA {
voidg() {
System.out.print(S);
}
public void f() {
System.out.print(" "+ S);
}
}
public class E {
public static void main(String[] args) {
ClassA a = new ClassB();
InterfaceA b = new ClassB();
a.g();
b.f();
}
}
A．编译正确，但无运行结果
B．编译错误：InterfaceAb = new ClassB();
C．good good
D．抛出异常
22．（*）下列程序运行的结果是（ ）。
interface Cryable {
voidcry();
}
class Dog implements Cryable {
publicvoid cry() {
System.out.print("汪汪 ");
}
}
class Cat implements Cryable {
public void cry() {
System.out.print("喵喵 ");
}
public static void main(String[] args) {
Cryable c = new Dog();
c.cry();
c = newCat();
c.cry();
}
}
A．编译错误 B．执行错误
C．汪汪 喵喵 D．以上都不对
23．（*）下列程序运行的结果是（ ）。
interface B {
void f();
}
class C implements B {
public void f() {
System.out.print("good ");
}
public void g(B b){
b.f();
}
}
class A implements B {
public void f() {
System.out.print("bad ");
}
public void g(B b){
b.f();
}
public static void main(String[] args) {
B b1 = new A();
B b2 = new C();
b1.f();
b2.f();
}
}
A．编译错误 B．执行错误
C．good bad D．bad good
二、简答题
1．请简述抽象类的概念和特点。
2．什么是抽象方法？抽象方法有何特点？
3．请简述抽象类与抽象方法之间的关系。
4．抽象类和接口有哪些共同点和区别？
三、编程题
1．（*）编写一个Java应用程序，要求实现如下类之间的继承关系：
（1）编写一个抽象类Shape，该类具有两个属性：周长length和面积area，具有两个抽象的方法：计算周长getLength()和计算面积getArea()。
（2）编写非抽象类矩形Rectangle和圆形Circle继承类Shape。
（3）编写一个锥体类Cone，里面包含两个成员变量Shape类型的底面bottom和double类型的高height。
（4）定义一个公共的主类TestShape，包含一个静态的方法void compute(Shape e)，通过该方法能够计算并输出一切图形的周长和面积；在主方法中调用compute方法，计算并输出某矩形和圆形的周长和面积，并测试锥体类Cone。
2．（*）按如下要求编写Java应用程序：
（1）编写一个抽象类Number，只含有一个抽象方法void method()。
（2）编写一个非抽象类Perfect继承类Number，在实现voidmethod()时，要求输出2到1000之间的所有完数（一个数如果恰好等于除它本身外的因子之和，这个数就称为完数。例如：6 = 1 ＋ 2 ＋ 3）。
（3）编写一个非抽象类Prime继承类Number，在实现voidmethod()时，要求输出2到100之间的所有素数（素数是指在一个大于1的自然数中，除了1和此整数自身外，无法被其他自然数整除的数，比如：3、5、7、11等）。
（4）编写测试类Test，在其main方法中测试类Perfect和Prime的功能。
3．（*）利用接口做参数，写个计算器，能完成加减乘除运算。
（1）定义一个接口Compute含有一个方法int computer(int n, int m)。
（2）设计四个类分别实现此接口，完成加减乘除运算。
（3）设计一个类UseCompute，类中含有方法：public void useCom(Compute com, int one, int two)，此方法能够用传递过来的对象调用computer方法完成运算，并输出运算的结果。
（4）设计一个主类Test，调用UseCompute中的方法useCom来完成加减乘除运算。
4．（*）按如下要求编写Java应用程序：
（1）编写一个用于表示战斗能力的接口Fightable，该接口包含：整型常量MAX；方法void win()，用于描述战斗者获胜后的行为；方法int injure(int x)，用于描述战斗者受伤后的行为。
（2）编写一个非抽象的战士类Warrior，实现接口Fightable。该类中包含两个整型变量：经验值experience和血液值blood。当战士获胜后经验值会增加，而受伤后血液值会减少x，并且当战斗者的血液值低于MAX时会输出危险提示。
（3）编写战士类Warrior的子类BloodWarrior，该类创建的战士在血液值低于MAX/2时才会输出危险提示。
（4）编写主类TestWarrior，对上述接口和类进行测试。
5．（*）按如下要求编写Java程序：
（1）编写一个接口：OneToN，只含有一个方法int dispose(int n)。
（2）编写一个非抽象类Sum来实现接口OneToN，实现int dispose (int n)接口方法时，要求计算1 + 2 + … + n。
（3）编写另一个非抽象类Pro来实现接口OneToN，实现int dispose (int n)接口方法时，要求计算1 * 2 * … * n。
（4）编写测试类Test，在main方法中使用接口回调技术来测试实现接口的类。
6．（*）按如下要求编写Java程序：
（1）编写接口InterfaceA，接口中含有方法void printCapitalLetter()。
（2）编写接口InterfaceB，接口中含有方法void printLowercaseLetter()。
（3）编写非抽象类Print，该类实现了接口InterfaceA和InterfaceB。要求printCapitalLetter()方法实现输出大写英文字母表的功能，printLowercaseLetter()方法实现输出小写英文字母表的功能。
（4）再写一个主类Test，在main方法中创建Print的对象并赋值给InterfaceA的变量a，由变量a调用printCapitalLetter方法，然后再创建Print的对象并将该对象赋值给InterfaceB的变量b，由变量b调用printLowercaseLetter方法。
7.（*）按如下要求编写Java程序：
（1）定义一个交通工具收费接口Charge，该接口包含两个元素：一个收取费用的方法double getFee(intdistance)，distance代表交通工具行驶的公里数；一个成员变量MAX，表示每次收取费用的最大值。
（2）定义列车类Train来实现这个接口，收费规则自行定义。
（3）定义主类Test，在main方法中输出收取费用的最大值，和行使2000公里后列车应收取的费用。
8.（*）设计一个Student接口，以一维数组存储一个班级的学生姓名。该接口中有一个抽象方法getStudentName()。设计一个类Union，该类实现接口Student中的方法getStudentName()，其功能是获取学生姓名并显示。
9.（*）按如下要求编写Java程序：
（1）定义接口A，里面包含值为3.14的常量PI和抽象方法double area()。
（2）定义接口B，里面包含抽象方法void setColor(String c)。
（3）定义接口C，该接口继承了接口A和B，里面包含抽象方法void volume()。
（4）定义圆柱体类Cylinder实现接口C，该类中包含三个成员变量：底圆半径radius、
圆柱体的高height、颜色color。
（5）创建主类来测试类Cylinder。
5.5 精选习题参考答案
一、单项选择题
1．B 2．D 3．D 4．D 5．A 6．D
7．D 8．C 9．D 10．B 11．A 12．A
13．B 14．B 15．B 16．A 17．C 18．B
19．D 20．B 21．C 22．C 23．D
二、简答题
1．
概念：由关键词abstract修饰的类叫抽象类。
特点：抽象类不能被实例化为对象，而只能作为其他类的父类，并且必须被继承；抽象类可以被子类继承，如果子类不是抽象类的话，那么子类必须实现抽象类（父类）中的所有抽象方法；final类不能被修饰为abstract类。
2．
概念：用abstract修饰的方法叫抽象方法，抽象方法没有方法体{ }，参数表后直接用分号结束。
特点：抽象方法必须声明在抽象类中；构造方法、static、final方法都不能声明为抽象方法，否则会产生编译错误；抽象方法必须被某个子类覆盖。
3．
一个抽象类里有没有定义抽象方法都可以，但含有抽象方法的类必定为抽象类，抽象方法必须定义在抽象类中。一个类没有全部实现从直接或者间接父类继承来的未被实现的抽象方法时，自身必须定义为抽象类。
4．
抽象类和接口的共同点大致有以下两个方面：
（1）接口的本质是特殊的抽象类，接口和抽象类都只能用public修饰权限。
（2）抽象类和接口都无法实例化。
抽象类和接口的区别大致有以下五个方面：
（1）抽象类中可以包含任意访问权限、任意类型的变量或常量；接口中只能包含公有的静态的常量。
（2）抽象类中可以包含任意访问权限的非抽象方法或抽象方法；接口中只能包含公有的抽象方法。
（3）抽象类中可以定义构造方法，但接口中禁止定义构造方法。
（4）抽象类支持单一继承，接口支持多重继承。
（5）抽象类是对类的抽象，继承了该类的对象同属于某一个较大的、共同的类别；接口是一种行为的规范，已实现该接口的类所创建的对象都具有某种共同的能力。
三、编程题
1．
abstract classShape {
double length, area;
abstract double getLength();
abstract double getArea();
}
class Circleextends Shape {
double radius;
Circle(double radius) {
this.radius = radius;
}
double getLength() {
length = 2 * 3.14 * radius;
return length;
}
double getArea() {
area = 3.14 * radius * radius;
return area;
}
}
class Rectangleextends Shape {
double width, height;
Rectangle(double width, double height) {
this.width = width;
this.height = height;
}
double getLength() {
length = (width + height) * 2;
return length;
}
double getArea() {
area = width * height;
return area;
}
}
class Cone {
Shape bottom;
double height;
public Cone(Shape bottom, double height) {
super();
this.bottom = bottom;
this.height = height;
}
double getVolume() {
return bottom.getArea() * height / 3;
}
}
public classTestShape {
public static void compute(Shape s) {
System.out.println(s.getClass());
System.out.println("周长为：" +s.getLength());
System.out.println("面积为：" +s.getArea());
}
public static void main(String[] args) {
Circle c = new Circle(5);
Rectangle r = new Rectangle(3, 4);
System.out.println("创建一个底面为圆形的锥体");
Cone cone = new Cone(c, 10);
compute(c);
System.out.println("体积为：" +cone.getVolume());
System.out.println("创建一个底面为矩形的锥体");
cone = new Cone(r, 10);
compute(r);
System.out.println("体积为：" +cone.getVolume());
}
}
程序的输出结果：
创建一个底面为圆形的锥体
class Circle
周长为：31.400000000000002
面积为：78.5
体积为：261.6666666666667
创建一个底面为矩形的锥体
class Rectangle
周长为：14.0
面积为：56.0
体积为：186.66666666666666
2.
abstract class Number{
abstract void method();
}
class Perfectextends Number {
void method() {
System.out.println("2到1000的完数如下：");
inti, j, sum;
for (i = 2; i <= 1000;i++) {
sum = 0;
for (j = 1; j <= i/ 2; j++) {
if (i % j == 0)
sum = sum + j;
}
if (sum == i)
System.out.print(i + "");
}
System.out.println();
}
}
class Prime extendsNumber {
void method() {
System.out.println("2到100的素数如下：");
int i, j;
for (i = 2; i <= 100; i++) {
for (j = 2; j <= i / 2; j++) {
if (i % j == 0)
break;
}
if (j > i / 2)
System.out.print(i+ " ");
}
System.out.println();
}
}
public class Test {
public static void main(String[] args) {
Number n = new Perfect();
n.method();
n = new Prime();
n.method();
}
}
程序的输出结果：
2到1000的完数如下：
6 28 496
2到100的素数如下：
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 5961 67 71 73 79 83 89 97
3.
interface Computer{
int computer(int n, int m);
}
class Addimplements Computer {
public int computer(int n, int m) {
return n + m;
}
}
class Subtractimplements Computer {
public int computer(int n, int m) {
return n - m;
}
}
class Multiplyimplements Computer {
public int computer(int n, int m) {
return n * m;
}
}
class Divideimplements Computer {
public int computer(int n, int m) {
return n / m;
}
}
class UseCompute {
public void useCom(Computer com, int one,int two) {
int result = com.computer(one, two);
System.out.println("结果是" +result);
}
}
public class Test {
public static void main(String[] args) {
Add add = new Add();
Subtract sub = new Subtract();
Multiplymul = new Multiply();
Divide div = new Divide();
UseCompute uc = new UseCompute();
uc.useCom(add, 25, 5);
uc.useCom(sub, 25, 5);
uc.useCom(mul, 25, 5);
uc.useCom(div, 25, 5);
}
}
程序的输出结果：
结果是30
结果是20
结果是125
结果是5
4.
interface Fightable{
int MAX = 10;
void win();
int injure(int x);
}
class Warriorimplements Fightable {
int experience;
int blood;
public void win() {
experience++;
System.out.println("获胜了，当前经验值为："+ experience);
}
public int injure(int x) {
blood = blood - x;
System.out.println("受伤了，当前血液值为："+ blood);
if (blood < MAX) {
System.out.println("危险，快点退出战斗！");
}
return blood;
}
}
class BloodWarriorextends Warrior {
public int injure(int x) {
blood = blood - x;
System.out.println("受伤了，当前血液值为："+ blood);
if (blood < MAX / 2) {
System.out.println("危险，快点退出战斗！");
}
return blood;
}
}
public classTestWarrior {
public static void main(String args[]) {
System.out.println("血液值的危险界限为"+ Warrior.MAX);
Warrior w1 = new Warrior();
w1.blood = 30;
System.out.println("普通战士开始战斗！");
for (int i = 1; i <= 2; i++) {
w1.injure(5);
}
w1.win();
Warrior w2 = new BloodWarrior();
w2.blood = 30;
System.out.println("斗士开始战斗！");
for (int i = 1; i <= 2; i++) {
w1.injure(5);
}
w2.win();
}
}
程序的输出结果：
血液值的危险界限为10
普通战士开始战斗！
受伤了，当前血液值为：25
受伤了，当前血液值为：20
获胜了，当前经验值为：1
斗士开始战斗！
受伤了，当前血液值为：15
受伤了，当前血液值为：10
获胜了，当前经验值为：1
5.
interface OneToN {
int dispose(int n);
}
class Sumimplements OneToN {
public int dispose(int n) {
int s= 0, i;
for (i = 1; i <= n;i++)
s += i;
return s;
}
}
class Proimplements OneToN {
public int dispose(int n) { // 实现接口中的dispose方法
int m = 1, i;
for (i = 1; i <= n; i++)
m *= i;
return m;
}
}
public class Test {
public static void main(String args[]) {
int n = 10;
OneToN s = new Sum();
OneToN p = new Pro();
System.out.println("1至" + n +"的和为" + s.dispose(n));
System.out.println("1至" + n +"的积为" + p.dispose(n));
}
}
程序的输出结果：
1至10的和为55
1至10的积为3628800
6.
interfaceInterfaceA {
void printCapitalLetter();
}
interfaceInterfaceB {
void printLowercaseLetter();
}
class Printimplements InterfaceA, InterfaceB {
public void printCapitalLetter() {
for (char c = 'A'; c <= 'Z'; c++) {
System.out.print(c + " ");
}
System.out.println();
}
public void printLowercaseLetter() {
for (char c = 'a'; c <= 'z'; c++) {
System.out.print(c + " ");
}
System.out.println();
}
}
public class Test {
public static void main(String[] args) {
InterfaceA a = new Print();
a.printCapitalLetter();
InterfaceB b = new Print();
b.printLowercaseLetter();
}
}
程序的输出结果：
A B C D E F G H I J K L M N O P Q R S T U V W XY Z
a b c d e f g h i j k l m n o pq r s t u v w x y z
7.
interfaceCharge{
int MAX = 10000;
double getFee(int distance);
}
class Trainimplements Charge{
double fee;
double rate = 0.3;
public double getFee(int distance) {
fee = distance * rate;
if(fee < MAX) {
return fee;
}else{
return MAX;
}
}
}
public class Test {
public static void main(String args[]) {
System.out.println("每次最多收费"+ Charge.MAX);
Train t = new Train();
System.out.println("行驶2000公里收费：" + t.getFee(2000));
}
}
程序的输出结果：
每次最多收费10000
行驶2000公里收费：600.0
8.
interface Student {
String[] names = { "张三","李四", "王五","周六", "吴七","郑八" };
String[] getStudentName();
}
public class Union implements Student {
public String[] getStudentName() {
for (int i = 0; i < names.length;i++) {
System.out.println(names[i]);
}
return names;
}
public static void main(String args[]) {
Student s = new Union();
s.getStudentName();
}
}
程序的输出结果：
张三
李四
王五
周六
吴七
郑八
9.
interface A { // 定义第1个接口
double PI = 3.14;
double getArea();
}
interface B { // 定义第2个接口
void setColor(String c);
}
interface C extendsA, B { // 接口的多重继承
void getVolume();
}
class Cylinderimplements C { // 以第3个接口实现类
double radius;
double height;
String color;
public Cylinder(double r, double h) {
radius = r;
height = h;
}
public double getArea() { // 实现第1个接口的方法
return PI * radius * radius;
}
public void setColor(String c) { // 实现第2个接口的方法
color = c;
System.out.println("形状的颜色："+ color);
}
public void getVolume() { // 实现第3个接口的方法
System.out.println("圆柱体的体积："+ getArea() * height);
}
}
class Test {
public static void main(String args[]) {
Cylinder One = new Cylinder(3.0, 5);
One.setColor("红色");
One.getVolume();
}
}
程序的输出结果：
形状的颜色：红色
圆柱体的体积：141.29999999999998
