2023年11月29日发(作者：)
第4章-Java语言与面向对象作
业习题与答案
第4章 Java语言与面向对象作业习题与答案
一、简答题
1．什么是对象？什么是类？
对象是一种抽象数据类型。它包含了事物的静
态特征（属性）和动态特征（行为）两大特征。
类是一组同种对象的集合与抽象。即是具有相
同属性和方法的一组对象集合。
2．Java语言的单继承是指什么？
一个类可以派生出多个子类，但子类只允许有
一个父类，而不允许存在多个父类。
3．在一个共有类中的数据成员及方法成员的访
问控制符为缺省，则这个类可供什么样的包引
用？
当一个类的访问控制符为public共有时，表明
这个类作为整体对其它类是可见和可引用的；但
其数据成员和方法成员访问控制符为缺省时，它
们只能被包中类（含当前类）引用。
4．抽象类的用途
（1）设计在更高的层次上进行，不考虑具体对
象，从而大大简化了处理问题的复杂性；
（2）设计出的类也具有更加良好的可扩展性。
5．什么是非静态的成员变量？
非静态成员即为实例成员变量（没有加static
修饰的变量）。
6．异常Exception和错误Error有什么不同？
Java如何处理它们？
答：错误通常是指程序本身存在非法情形，
常常是因为代码存在问题而引起的，如造成
系统崩溃、虚拟机粗错、动态链接失败等，
这一类错误无法恢复或不可能捕获，并将导
致应用程序中断。
异常表示另外一种“非同寻常”的错误。这
种错误通常是不可预测，但可以被捕获且可以
恢复。常见的异常情况包括内存不足、找不到
所需文件等。
对于错误，编程人员可以通过对程序进行更
仔细的检查，以避免这种错误。
对于异常，可以使用捕获机制进行捕获，再
编写出相应的处理程序。
7．简单陈述Java的异常处理机制。
答：Java采取“抛出—捕获”的方式，一旦
一个异常想象产生，Runnable环境和应用程
序会抛出各种标准类型和自己定义的异常，
系统就可以捕获这些异常，并一定有相应的
机制来处理它，确保不会产生司机、死循环
或其它对操作系统的损害，从而保证了整个
程序运行的安全性。
8．简单陈述throw语句和throws关键字之间的
差别。
答：throw语句是在一个方法中用来直接抛出
异常对象，其格式是：
throw 异常对象；
throws关键字是用一个方法声明首部，用来
指出这个方法中可能产生若干种异常，其格式：
[方法修饰符] 返回类型 方法名（参数表）
throws 异常类型表
{ /*方法体*/ }
二、填空题
1．所有Java应用程序都必须包含的一个类方法
是 main() 。
2．面向对象程序设计语言的三种重要特性是封
装性、继承性和多态性。
3．方法重载与方法覆盖的不同有：方法重载是
指允许在同一个类中定义多个同名方法，它们通
过形参的个数或形参参数的类型来区别；方法覆
盖是指在子类中重新定义了与父类中的方法同名
的方法。
4．面向对象程序设计语言的多态的事项方法主
要有三种：方法重载、方法覆盖和接口。
5．对象之间的信息通过消息传递机制来完成。
6．成员变量的修饰符有（写出6种）public,
friendly, protected, private, final, static。
7．整个类共同拥有的方法是用static修饰的方
法或叫类成员方法；它具有统计一个类的实例个
数等用途。
8．引用父类中的成员用super；引用当前的类或
对象用this。
9．在面向对象中，继承有两种含义，分别指在
1
类的层次结构中，子类自动继承父类的特性和同
一类的所有实例对象都具有所属类的特征。
10．在Java语言中，所有类都是Object类的子
类。
11．多继承问题指的是一个类有多个父类问题；
在Java语言中通过接口方法解决多继承问题。
12．接口是一种特殊的类，它只能定义一些抽象
方法和常量。
13．在Java语言中，一组类和接口的集合通常
被称为类库或API包或应用程序接口。
14．给出引用包的两种方法是：使用包名、类名
做前缀；使用import语句。
15．Java语言异常处理三种方式是：捕获异常、
声明异常和自定义异常
16．程序设计过程中可能会出现的两种错误是编
译错误和运行错误。
17．程序设计过程后的运行错误大致有三类。它
们是逻辑错误、用户输入不合法和硬件设备出错。
18．在Java语言中，用try-catch-final结构来捕
获并处理异常。
19．用户程序使用throw new 异常类名；抛出
自己的异常。
20．自定义异常类必须继承Exception类。
三、选择题
1．下述声明中哪一种可以防止该类产生子类？
A．static class DEF{} B．private
calss DEF{}
C．abstract class DEF{} D．final
public class DEF{}
E．final abstract class DEF{}
答案：D。
Final防止有子类继承，因此可选择D、E。但
final不可以和abstract连用，因此E也错。
2．如果要求子类可以在任何包中访问父类的成
员，下面哪一个修饰符可以达到这个目标的最为
严格的修饰符？
A．public B．private C．protected
D．无修饰符
2
答案：C。
A和C都可以做到这点，但A更为宽松，不仅
仅是任何包中的子类，而且任何包中和包外的类
都可以访问它。D只能被同一个包内的类访问，
所以D不符合要求。而B比D更为严格。
3．程序的封装性是如何实现的？
A．由应用程序的设计者实现 B．由应
用程序的使用者实现
C．由应用程序的设计和使用者实现
D．由操作系统实现
答案：A。
4．下列哪个选项是错误的？
A．子类对象可以转化成父类对象
B．父类对象一般不转化成子类对象
C．子类对象与父类对象之间不能转化
D．子类对象转化为父类对象后，对于子类与
父类共有的方法，仍然调用子类的方法。
答案：C。
5．下列哪个选项能体现Java语言的多态性？
A．匿名类 B．内布类 C．方法重载
D．方法覆盖
答案：C。
6．下列哪个选项正确？
A．Error类是一个RuntimeException异常
B．任何抛出一个RuntimeException异常的语
句必须包含在try块内。
C．任何抛出一个Error对象的语句必须包含
在try块内。
D．任何抛出一个Exception异常的语句必须包
含在try块内。
答案：D
Error代表程序中不可捕获的问题，与
Exception类同在一个层次，而RuntimeException
是Exception的子类，所以Error类不可能是一
个RuntimeException类型的异常；抛出一个
RuntimeException异常不一定要在try块内，它
是由JVM正常抛出，不需要throw和throws语
句，因而也不一定要有catch语句去捕获，所以
可以不出现在try块中；Error类型的问题是不可
3
恢复的，多以没有规定要去捕获Error，因而也
可以不出现在try块中；对于抛出一个Exception
对象的语句，如果没有包含在try块之内，有可
能编译不能通过，因此选项D是必须的。
7．有如下程序，给出程序运行结果？
import .*;
public class ExceptionTest
{ public static void main(String args[])
{ try
{ methodA(); }
catch(IOException e){
n(“Caught Exception”);
}
public void methcdA()
{ throw new IOException(); }
}
}
A．代码不能编译 B．输出：
Caught Exception
C．输出：CaughtIO Exception
D．程序正常运行后无任何信息输出
答案：A
首先，methcdA是非静态方法，不能出现在
main中；其次，就算methcdA是静态方法，
IOException是可检测异常，必须被catch捕获或
是被throws声明，但程序中没有声明throws，所
以try语句块不可能抛出IOException这个异常，
而catch也就谈不到捕获它了，所以两个条件都
没有满足，编译同样错误。
在methcdA方法定义语句的前面加static，后
面加上throws IOException，程序就可以调试通
过了。
8．有如下程序，在程序的point x处增加如下哪
个选项程序才能通过编译？
public class ExceptionTest
{ calss TestException extends Exception{}
public void runTest() throws
TestException{}
public void test() //point x
4
{ runTest(); }
}
A．throws Exception
B．catch(Exception)
C．throws RuntimeException
D．catch(TestException)
答案：A
没有try就不能有catch，所以B，D错；而
C里边的RuntimeException是Exception的子
类，不能用捕“小鱼”的工具去捕“大鱼”，所
以错误；由于runTest()抛出的是TestExcption，
而TestExcption又是Excption的子类，因此用
到runTest方法就必须抛出Excption异常。
9．有如下程序，该程序的运行结果是？
public class Exc_4
{ public static void main(String args[])
{ try{ return; }
finally{ n(“Finally”);
}
}
}
A．程序无输出 B．程序输出
“Finally”
C．代码可以通过编译但执行时产生异常
D．因为缺少catch块所以编译出错
答案：B
程序中有catch则必须有try，但反之不成立，
所以D不对；关于try-catch-finally的问题，
程序中如果遇到return，则finally块先被执
行，然后再执行return，而finally块后面的
语句将不被执行。如果遇到(1)，
则退出JVM，整个程序退出，当然finally
块其后的语句都不执行。
10．有如下程序，如果methodA()抛出
IOException异常，该程序的运行结果是？
class Exc_5
{ public static void main(String args[])
{ try{ methodA(); }
catch(IOException e){
5
n(“caught IOException”); }
catch(Exception
e){ n(“caught Exception”);} }
}
}
答案：caught IOException
如果methodA()抛出IOException异常，被
语句5捕获，输出“caught IOException”
四、编程题
1．试编写出要创建一个员工类Employee。这
个类中的一个成员变量应该包括员工号
empNum、姓名Name；其操作方法一个是用来设
置set员工的工号，另一个操作方法是用来取得
get员工工号。（建议按两步完成设计：一步是写
出类的头结构；另外一步是完成成员声明。）
class Employee
{ public empNum;
public Name;
public int setNum(int _empNum)
{
int empNum=_empNum;
return empNum;
}
int void getNum()
{
Employee A;
int empNum=(2001);
n("员工工号为：" +
empNum);
}
}
2．创建一个名为List的显示类，它可以存储任
何类型的对象，并可以在任何时候增加或删除对
象。
class List
{ private int maxItems=100;
6
private int numItems=0;
private Object[] list=null;
public List()
{ list=new Object[maxItems]; }
public List(int _maxItems)
{
maxItems=_maxItems;
list=new Object[maxItems];
}
public void add(Object obj)
{
list[numItems]=obj;
numItems++;
}
public void delete(int pos)
{
for(int i=pos+1; i<numItems; i++)
{ list[i-1]=list[i]; }
numItems--;
}
public Object get(int pos)
{ return list[pos]; }
public int getSize()
{ return numItems; }
public boolean isFull()
{ return (numItems>=maxItems); }
public String toString()
{ String s=new String();
for(int i=0; i<numItems; i++)
{ s+="n"+list[i].toString(); }
return s+"n";
}
}
public class ListTest
{ public static void main(String[] args)
{
List list=new List();
(new Double(10.0));
(new String("Java by Definition"));
7
(new Integer(-10));
System.out.println(list);
System.out.println("Position 0:"+(1));
(2);
(0);
System.out.println("List
Size:"+e());
}
}
程序运行结果：
10.0
Java by Definition
-10
Position 0:Java by Definition
List Size:1
3．创建帐号SavingsAccount类。用静态变量存
储年利率。该类的每个对象都有一个私有实例变
量savingBalance用来显示帐号里的钱数。提供方
法calculateMonthlyInterest计算月利息（按照年
利率乘以帐号里的钱数再除以12）；该利息必须
加到实例变量中。提供一个静态方法
modifyInterestRate设置年利率。写一个测试程序
CalculatorInterest来测试该类。建立两个该类对
象，saver1和saver2，分别有人民币2000元和
3000元。设年利率为4%。计算每个帐号的月利
息及新的钱数。设年利率为5%。计算每个帐号
下月的利息及新钱数。
import .*;
public class CalculatorInterest
//测试程序
{ public static void main(String args[])
{ SavingsAccount saver1=new
SavingsAccount(2000); //声明两个对象
SavingsAccount saver2=new
SavingsAccount(3000);
SavingsAccount.modifyInterestRate(0.04);
8
//设置利率为4%
System.out.print("InterestRate");
//输出利率
();
System.out.print("saver1’s balance is:");
//输出用户1的总额
();
System.out.print("saver2’s balance is:");
//输出用户2的总额
();
SavingsAccount.modifyInterestRate(0.05);
//设置利率为5%
System.out.print("InterestRate");
//输出利率
();
System.out.print("saver1’s balance is:");
//输出用户1的总额
();
System.out.print("saver2’s balance is:");
//输出用户2的总额
();
}
}
class SavingsAccount
{ private double savingsBalance; //
声明实例变量
static double annualInterestRate;
//声明静态变量
public SavingsAccount(double
x){ savingsBalance=x; } //构造函数
9
public void add(double x)
{ savingsBalance= savingsBalance+x; }
//计算总存款
public static void modifyInterestRate(double x)
{ annualInterestRate=x; } //
年利率
public void printB()
{ System.out.println(savingsBalance*(1+annua
lInterestRate)); } //输出总额
public void printR()
{ System.out.println(annualInterestRate); }
//输出年利息
}
程序运行结果：
InterestRate0.04
saver1’s balance is:2080.0
saver2’s balance is:3120.0
InterestRate0.05
saver1’s balance is:2100.0
saver2’s balance is:3150.0
4．设计一个交通工具类vehicle，其中的属性包
括速度speed、种类kind；方法包括：设置颜色
setColor，取得颜色getColor。再设计一个子类
Car，增加属性passenger表示可容纳旅客人数，
添加方法取得最大速度getMaxSpeed()。
import .*;
public class vehicle
{ private int speed;
private String kind;
private Color color;
public vehicle()
{ speed=2000;
kind= "TO";
color=Color.red;
10
}
public vehicle(int s, String k, Color c)
{ speed=s;
kind= k;
color=c;
}
public void setColor(Color cl)
{ color=cl; }
public void getColor(String)
{ if(equals(kind, k))
{ return color; }
}
}
class Car extends vehicle
{ super(2000,"DD",blue);
int passengers;
public int getMaxSpeed()
{
……
}
}
5．编写3个接口A、B、C，它们之间具有继承
关系。B接口继承与A，C接口继承B；且每个
接口中包含一个常量字符串。试通过一个类
ImpInterfaceABC继承这些接口，通过
interfaceinheritanceTest类显示接口中常量字符
串来展示接口的继承性。
interface A
{ String a="接口A中的常量";
void showA();
}
interface B extends A
{ String b="接口B中的常量";
void showB();
}
interface C extends B
{ String c="接口C中的常量";
void showC();
}
11
class ImpInterfaceABC implements C
{ public void
showA(){System.out.println(a); }
public void showB(){System.out.println(b); }
public void showC(){System.out.println(c); }
}
class interfaceinheritanceTest
{ public static void main(String args[])
{ ImpInterfaceABC intf=new
ImpInterfaceABC();
();
();
();
}
}
程序运行结果：
接口A中的常量
接口B中的常量
接口C中的常量
** ．学校学生图书管理应用程序。某国大学的
学生图书馆管理系统。因为正常借阅是免费的，
但超时借阅就要接受罚款处理，根据超时时间可
分类处罚，一是在超时在两个月内，每本书按其
价格的50%罚款；超过两个月的罚款按借阅图书
的3倍处罚。处罚收费管理账单上包含有院系名
称、学生姓名、信用图书超时间以及处罚金额。
12
发布评论