第4章Java语言与面向对象作业习题与答案.docx
《第4章Java语言与面向对象作业习题与答案.docx》由会员分享，可在线阅读，更多相关《第4章Java语言与面向对象作业习题与答案.docx（15页珍藏版）》请在冰点文库上搜索。
第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．在面向对象中，继承有两种含义，分别指在类的层次结构中，子类自动继承父类的特性和同一类的所有实例对象都具有所属类的特征。
10．在Java语言中，所有类都是Object类的子类。
11．多继承问题指的是一个类有多个父类问题；在Java语言过接口方法解决多继承问题。
12．接口是一种特殊的类，它只能定义一些抽象方法和常量。
13．在Java语言中，一组类和接口的集合通常被称为类库或API包或应用程序接口。
14．给出引用包的两种方法是：
使用包名、类名做前缀；使用import语句。
15．Java语言异常处理三种方式是：
捕获异常、声明异常和自定义异常
16．程序设计过程中可能会出现的两种错误是编译错误和运行错误。
17．程序设计过程后的运行错误大致有三类。
它们是逻辑错误、用户输入不合法和硬件设备出错。
18．在Java语言中，用try-catch-final结构来捕获并处理异常。
19．用户程序使用thrownew异常类名；抛出自己的异常。
20．自定义异常类必须继承Exception类。
三、选择题
1．下述声明中哪一种可以防止该类产生子类？
A．staticclassDEF{}B．privatecalssDEF{}
C．abstractclassDEF{}D．finalpublicclassDEF{}
E．finalabstractclassDEF{}
答案：
D。
Final防止有子类继承，因此可选择D、E。
但final不可以和abstract连用，因此E也错。
2．如果要求子类可以在任何包中访问父类的成员，下面哪一个修饰符可以达到这个目标的最为严格的修饰符？
A．publicB．privateC．protectedD．无修饰符
答案：
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类型的问题是不可恢复的，多以没有规定要去捕获Error，因而也可以不出现在try块中；对于抛出一个Exception对象的语句，如果没有包含在try块之，有可能编译不能通过，因此选项D是必须的。
7．有如下程序，给出程序运行结果？
importjava.io.*;
publicclassExceptionTest
{publicstaticvoidmain（Stringargs[]）
{try
{methodA（）;}
catch（IOExceptione）{System.out.println（“CaughtException”）;}
publicvoidmethcdA（）
{thrownewIOException（）;}
}
}
A．代码不能编译B．输出：
CaughtException
C．输出：
CaughtIOExceptionD．程序正常运行后无任何信息输出
答案：
A
首先，methcdA是非静态方法，不能出现在main中；其次，就算methcdA是静态方法，IOException是可检测异常，必须被catch捕获或是被throws声明，但程序中没有声明throws，所以try语句块不可能抛出IOException这个异常，而catch也就谈不到捕获它了，所以两个条件都没有满足，编译同样错误。
在methcdA方法定义语句的前面加static，后面加上throwsIOException，程序就可以调试通过了。
8．有如下程序，在程序的pointx处增加如下哪个选项程序才能通过编译？
publicclassExceptionTest
{calssTestExceptionextendsException{}
publicvoidrunTest（）throwsTestException{}
publicvoidtest（）//pointx
{runTest（）;}
}
A．throwsExceptionB．catch（Exception）
C．throwsRuntimeExceptionD．catch（TestException）
答案：
A
没有try就不能有catch，所以B，D错；而C里边的RuntimeException是Exception的子类，不能用捕“小鱼”的工具去捕“大鱼”，所以错误；由于runTest（）抛出的是TestExcption，而TestExcption又是Excption的子类，因此用到runTest方法就必须抛出Excption异常。
9．有如下程序，该程序的运行结果是？
publicclassExc_4
{publicstaticvoidmain（Stringargs[]）
{try{return;}
finally{System.out.println（“Finally”）;}
}
}
A．程序无输出B．程序输出“Finally”
C．代码可以通过编译但执行时产生异常D．因为缺少catch块所以编译出错
答案：
B
程序中有catch则必须有try，但反之不成立，所以D不对；关于try-catch-finally的问题，程序中如果遇到return，则finally块先被执行，然后再执行return，而finally块后面的语句将不被执行。
如果遇到System.exit
（1），则退出JVM，整个程序退出，当然finally块其后的语句都不执行。
10．有如下程序，如果methodA（）抛出IOException异常，该程序的运行结果是？
classExc_5
{publicstaticvoidmain（Stringargs[]）
{try{methodA（）;}
catch（IOExceptione）{System.out.println（“caughtIOException”）;}
catch（Exceptione）{System.out.println（“caughtException”）;}}
}
}
答案：
caughtIOException
如果methodA（）抛出IOException异常，被语句5捕获，输出“caughtIOException”
四、编程题
1．试编写出要创建一个员工类Employee。
这个类中的一个成员变量应该包括员工号empNum、Name；其操作方法一个是用来设置set员工的工号，另一个操作方法是用来取得get员工工号。
（建议按两步完成设计：
一步是写出类的头结构；另外一步是完成成员声明。
）
classEmployee
{publicempNum;
publicName;
publicintsetNum（int_empNum）
{
intempNum=_empNum;
returnempNum;
}
intvoidgetNum（）
{
EmployeeA;
intempNum=A.setNum（2001）;
System.out.println（"员工工号为：
"+empNum）;
}
}
2．创建一个名为List的显示类，它可以存储任何类型的对象，并可以在任何时候增加或删除对象。
classList
{privateintmaxItems=100;
privateintnumItems=0;
privateObject[]list=null;
publicList（）
{list=newObject[maxItems];}
publicList（int_maxItems）
{
maxItems=_maxItems;
list=newObject[maxItems];
}
publicvoidadd（Objectobj）
{
list[numItems]=obj;
numItems++;
}
publicvoiddelete（intpos）
{
for（inti=pos+1;i{list[i-1]=list[i];}
numItems--;
}
publicObjectget（intpos）
{returnlist[pos];}
publicintgetSize（）
{returnnumItems;}
publicbooleanisFull（）
{return（numItems>=maxItems）;}
publicStringtoString（）
{Strings=newString（）;
for（inti=0;i{s+="\n"+list[i].toString（）;}
returns+"\n";
}
}
publicclassListTest
{publicstaticvoidmain（String[]args）
{
Listlist=newList（）;
list.add（newDouble（10.0））;
list.add（newString（"JavabyDefinition"））;
list.add（newInteger（-10））;
System.out.println（list）;
System.out.println（"Position0:
"+list.get
（1））;
list.delete
（2）;
list.delete（0）;
System.out.println（"ListSize:
"+list.getSize（））;
}
}
程序运行结果：
10.0
JavabyDefinition
-10
Position0:
JavabyDefinition
ListSize:
1
3．创建SavingsAccount类。
用静态变量存储年利率。
该类的每个对象都有一个私有实例变量savingBalance用来显示里的钱数。
提供方法calculateMonthlyInterest计算月利息（按照年利率乘以里的钱数再除以12）；该利息必须加到实例变量中。
提供一个静态方法modifyInterestRate设置年利率。
写一个测试程序CalculatorInterest来测试该类。
建立两个该类对象，saver1和saver2，分别有人民币2000元和3000元。
设年利率为4%。
计算每个的月利息及新的钱数。
设年利率为5%。
计算每个下月的利息及新钱数。
importjava.io.*;
publicclassCalculatorInterest//测试程序
{publicstaticvoidmain（Stringargs[]）
{SavingsAccountsaver1=newSavingsAccount（2000）;//声明两个对象
SavingsAccountsaver2=newSavingsAccount（3000）;
SavingsAccount.modifyInterestRate（0.04）;//设置利率为4%
System.out.print（"InterestRate"）;//输出利率
saver1.printR（）;
System.out.print（"saver1’sbalanceis:
"）;//输出用户1的总额
saver1.printB（）;
System.out.print（"saver2’sbalanceis:
"）;//输出用户2的总额
saver2.printB（）;
SavingsAccount.modifyInterestRate（0.05）;//设置利率为5%
System.out.print（"InterestRate"）;//输出利率
saver1.printR（）;
System.out.print（"saver1’sbalanceis:
"）;//输出用户1的总额
saver1.printB（）;
System.out.print（"saver2’sbalanceis:
"）;//输出用户2的总额
saver2.printB（）;
}
}
classSavingsAccount
{privatedoublesavingsBalance;//声明实例变量
staticdoubleannualInterestRate;//声明静态变量
publicSavingsAccount（doublex）{savingsBalance=x;}//构造函数
publicvoidadd（doublex）
{savingsBalance=savingsBalance+x;}//计算总存款
publicstaticvoidmodifyInterestRate（doublex）
{annualInterestRate=x;}//年利率
publicvoidprintB（）
{System.out.println（savingsBalance*（1+annualInterestRate））;}//输出总额
publicvoidprintR（）
{System.out.println（annualInterestRate）;}//输出年利息
}
程序运行结果：
InterestRate0.04
saver1’sbalanceis:
2080.0
saver2’sbalanceis:
3120.0
InterestRate0.05
saver1’sbalanceis:
2100.0
saver2’sbalanceis:
3150.0
4．设计一个交通工具类vehicle，其中的属性包括速度speed、种类kind；方法包括：
设置颜色setColor，取得颜色getColor。
再设计一个子类Car，增加属性passenger表示可容纳旅客人数，添加方法取得最大速度getMaxSpeed（）。
importjava.awt.*;
publicclassvehicle
{privateintspeed;
privateStringkind;
privateColorcolor;
publicvehicle（）
{speed=2000;
kind="TO";
color=Color.red;
}
publicvehicle（ints,Stringk,Colorc）
{speed=s;
kind=k;
color=c;
}
publicvoidsetColor（Colorcl）
{color=cl;}
publicvoidgetColor（String）
{if（equals（kind,k））
{returncolor;}
}
}
classCarextendsvehicle
{super（2000,"DD",blue）;
intpassengers;
publicintgetMaxSpeed（）
{
……
}
}
5．编写3个接口A、B、C，它们之间具有继承关系。
B接口继承与A，C接口继承B；且每个接口中包含一个常量字符串。
试通过一个类ImpInterfaceABC继承这些接口，通过interfaceinheritanceTest类显示接口中常量字符串来展示接口的继承性。
interfaceA
{Stringa="接口A中的常量";
voidshowA（）;
}
interfaceBextendsA
{Stringb="接口B中的常量";
voidshowB（）;
}
interfaceCextendsB
{Stringc="接口C中的常量";
voidshowC（）;
}
classImpInterfaceABCimplementsC
{publicvoidshowA（）{System.out.println（a）;}
publicvoidshowB（）{System.out.println（b）;}
publicvoidshowC（）{System.out.println（c）;}
}
classinterfaceinheritanceTest
{publicstaticvoidmain（Stringargs[]）
{ImpInterfaceABCintf=newImpInterfaceABC（）;
intf.showA（）;
intf.showB（）;
intf.showC（）;
}
}
程序运行结果：
接口A中的常量
接口B中的常量
接口C中的常量
**．学校学生图书管理应用程序。
某国大学的学生图书馆管理系统。
因为正常借阅是免费的，但超时借阅就要接受罚款处理，根据超时时间可分类处罚，一是在超时在两个月，每本书按其价格的50%罚款；超过两个月的罚款按借阅图书的3倍处罚。
处罚收费管理账单上包含有院系名称、学生、信用图书超时间以及处罚金额。
升级会员 