课后答案.docx
《课后答案.docx》由会员分享，可在线阅读，更多相关《课后答案.docx（34页珍藏版）》请在冰豆网上搜索。
课后答案
第一章引言
一、填空题
1、J2SE、J2EE、J2ME
2、Java虚拟机
3、数据分布、操作分布
二、简答题
1、答：
Java的主要特点是简单、面向对象、平台无关性、分布式、安全稳定、支持多线程、内存垃圾自动回收。
2、答：
开发工具主要分为集成开发环境和JDK。
集成开发环境包含的主要工具有Jbuilder、Eclipse、MyEclipse、visualj++、JCreator等。
3、答：
假设JDK安装在C盘下的目录中，从桌面上选择“我的电脑”（右键）→属性→高级→环境变量；在其中选择“系统变量”的“新建”，在变量名中输入CLASSPATH，变量值中输入类库名C:
\ProgramFiles\Java\jdk1.6.0_07\lib\dt.jar;C:
\ProgramFiles\Java\jdk1.6.0_07\lib\tools.jar，然后选择确定；再次选择“系统变量”的“新建”，在变量名中输入PATH，变量值中输入C:
\ProgramFiles\Java\jdk1.6.0_07\bin，然后选择确定。
4、答：
（1）【ALT+/】：
此快捷键为用户编辑的好帮手，能为用户提供内容的辅助，不要为记不全方法和属性名称犯愁，当记不全类、方法和属性的名字时，就可以用【ALT+/】提示功能。
（2）【Ctrl+/】用于快速添加或消除注释。
（3）【Ctrl+Shift+O】用于快速生成import语句。
（4）【Ctrl+Shift+F】用于格式化代码。
第二章Java基本程序结构
一、单选题
1.D2.B3.B4.C5.D6.B7.D8.C9.C10.B
二、多选题
1.BCDE2.AB3.ABFG4.CE5.CD
三、简答题
1.答：
标识符必须以字母（大小写）、下划线（_）或美元符（$）开头；标识符是由数字（0--9），字母（大小写）和下划线（_）、美元符（$）构成；标识符不能使用系统保留的关键字，如public、main、new等；标识符应该具有一定的含义，反映数据对象的含义；Java是大小写敏感的语言，class和Class、System和system分别代表不同的标识符。
2.答：
Java有3中注释形式：
（1）“//”：
单行注释，表示从此向后，直到行尾都是注释，只对一条语句进行注释。
（2）“/**/”：
块注释，在“/*”和“*/”之间都是注释，块注释不能直接嵌套。
可以同时对多条语句进行注释。
（3）“/***/”：
文档注释，利用Javadoc命令生成文档，所有在“/**”和“*/”之间的内容都是可以用来自动形成文档。
主要对方法的参数进行说明。
3答：
基本类型的变量直接把变量的值保存在堆栈中，这与C++语言中的变量类似；引用类型的变量把实际数据的地址保存在堆栈中，而实际的数据则保存在堆中，这与C++语言中的指针类似。
4.答：
数据类型转换分为自动转换和强制转换两种。
凡是将变量从占用内存较少的短数据类型转换成占用内存较多的长数据类型时，可以自动转换，自动转换时遵循从占内存少的数据转换到占内存多的数据的转换规则。
将数据从较长的数据类型转换成较短的数据类型时，需要强制转换。
5.答：
常量是在程序运行的过程中值不可改变。
变量是在程序运行过程中值可改变。
它们之间的最大区别就是值可变不可变。
6.答：
由于Java字符数据类型采用了Unicode编码方案，Java处理多种语言的能力大大加强。
每个Unicode码占用16比特位，包含的信息量比ASII码多了256倍，无论东方字符还是西方字符，都可以统一用一个字符表达式。
7.答：
break作用是结束循环，继续执行循环以外的代码；continue作用是结束当前的循环，继续下一轮循环；return作用是结束循环，从当前函数中跳出。
8.答：
（1）、1
（2）、true（3）、0（4）、2
9.答：
数组是相同数据类型的元素按一定的顺序现行排列就构成数组。
数组特点是：
.相同数据类型的元素的集合；数组中的各元素是有先后顺序的，空间大小固定；每个数组元素用整个数组的名字和它自己在数组中的位置表达。
创建数组的步骤是先声明，再初始化。
10.答：
字符串是字符序列，有些类似于字符数组。
字符串可以分为两大类，一类是创建之后不会再做修改和变动的字符串常量，存放在String类的对象中；另一类是创建之后允许再做更改和变化的字符串变量，存放在StringBuffer类的对象中或存放在StringBuilder类的对象中。
StringBuffer的方法append（）用来在末尾处扩充其包含的字符，insert（）作用是指定的位置插入由参数转化的字符串。
四、编程题
1.
importjava.io.*;
publicclassMaxValue{
publicstaticvoidmain（String[]args）{
inta=23,b=45,c=99,s;
if（a>b）
{
if（a>c）
{
s=a;
}
else
{
s=c;
}
}
else
{
if（b>c）
{
s=b;
}
else
{
s=c;
}
}
System.out.println（"三个数中最大的是"+s）;
}
}
2.
importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
publicclassMonth{
publicstaticvoidmain（String[]args）throwsIOException{
intnum;
Stringstr;
BufferedReaderbuf;
buf=newBufferedReader（newInputStreamReader（System.in））;
System.out.print（"输入一个整数:
"）;
str=buf.readLine（）;//将输入的文字指定给字符串变量str存放
num=Integer.parseInt（str）;//将str转成int类型后指定给num存放
while（num<1||num>12）{
System.out.println（"输入的数据不符合要求,请重新输入"）;
System.out.print（"输入:
"）;
str=buf.readLine（）;
num=Integer.parseInt（str）;
}
switch（num）
{
case1:
System.out.println（"一月"）;
break;
case2:
System.out.println（"二月"）;
break;
case3:
System.out.println（"三月"）;
break;
case4:
System.out.println（"四月"）;
break;
case5:
System.out.println（"五月"）;
break;
case6:
System.out.println（"六月"）;
break;
case7:
System.out.println（"七月"）;
break;
case8:
System.out.println（"八月"）;
break;
case9:
System.out.println（"九月"）;
break;
case10:
System.out.println（"十月"）;
break;
case11:
System.out.println（"十一月"）;
break;
case12:
System.out.println（"十二月"）;
break;
}
}
}
3.
publicclassStringBuffers{
publicstaticvoidmain（String[]args）{
StringBufferstb=newStringBuffer（"Hello"）;
stb.append（"World!
"）;//在原来的字符串后面追加World
stb.insert（6,"Beautiful"）;//在中间插入字符串Beautiful
System.out.print（stb）;
}
}
4.
publicclassXunHuan{
publicstaticvoidmain（String[]args）{
//TODO自动生成方法存根
inti;
System.out.println（"第一个循环:
"）;
for（i=10;i<=50;i++）{
if（（i%3）==0）
System.out.println（i）;
}
System.out.println（"第二个循环:
"）;
i=10;
while（i<50）{
if（i%3==0）
System.out.println（i）;
i++;
}
System.out.println（"第三个循环:
"）;
i=10;
do{
if（i%3==0）
System.out.println（i）;
i++;
}while（i<50）;
}
}
第三章对象和类
一、填空
（1）封装性、继承性、多态性
（2）动态多态、静态多态、静态多态
（3）属性、行为、对象域的取值、方法
（4）new、“.”
（5）Package、import
二、单项选择
1.D
2.C
3.D
4.B
5.B
三、简答
1.简述类的特征并举例说明。
答：
对象是现实世界中的一个实体，其特征是：
每个对象必须有一个名字以区别其它对象；用属性（状态）来描述它的某些特征；有一组操作（方法），每一个操作决定对象的一种行为。
比如：
教师王刚是一个对象。
对象名的名字为王刚，它包含以下属性：
年龄、学历、职称等，他包含的操所为：
讲课、开发软件及出版教材等。
2.什么是类，以及对象与类关系是什么？
答：
“类”是对一组具有共同的属性特征和行为特征的对象的抽象。
类和对象之间是抽象和具体的关系。
类是对多个对象进行综合抽象的结果，对象又是类的个体实物，一个对象是类的一个实例。
例如由一个个人抽象出人类，而一个人是人类的一个实例。
3.具有继承关系的类之间应具有哪些特性。
答：
类之间具有继承关系，则他们之间具有下列几个特性：
类间具有共享特征（包括数据和程序代码的共享）、类间具有差别或新增部分（包括非共享的数据和程序代码）、类间具有层次结构。
4.简述设计类的原则。
答：
1.尽量将数据设计为私有属性。
2.尽量对变量进行初始化3.尽量减少类中的原始类型变量。
4.尽量使用一个标准统一的类定义格式5.类的功能尽量单一。
6.取有意义的名字
四、编程题
略
第四章继承与多态
一、填空
1.class、extends
2.this、super
3.抽象方法、抽象类、abstract
4.多重、接口、interface、implements
5.public、abstract、public、static、final
二、单项选择
1.C
2.A
3.B
4.A
5.C
6.C
三、简答
1.简述为什么用使用抽象类并举例说明。
答：
在定义一个类的时候，经常会碰到这样的情况；有一些方法对于所有的对象都是合适的，但有些方法只对某个特定类型的对象才有意义。
这些方法在这个类中是不能实现的，把这种类定义为抽象类。
某些类在现实世界中是不能直接找到对应得实例的，如车这个类，不可能为它找到一个对应的事物，因为现实世界中只有汽车，自行车，火车等事物，而它们都是车的子类，这样的类称为抽象类。
2.简述接口的使用方法及其结构特点。
答：
接口的使用方法是：
首先定义一个接口，可以先把它理解成一个特殊的类，然后在某个类中要使用这个接口时，就在这个类的定义时声明要实现的某个接口，就相当于多重继承中子类声明它要继承另一个父类。
从结构上说，接口有如下的特点：
接口用关键字interface来定义，而不是class；接口中定义的变量全都是静态变量，而且都是最终的静态变量；接口中没有自身的构造方法，而且定义的方法都是抽象方法，即只提供方法的定义，而不提供具体的实现；接口采用多重继承机制，而不是采用类的单重继承机制。
3.简述接口和抽象类的区别。
答：
接口中的所有方法都是抽象的，而抽象类可以定义一般的方法。
一个类中可以实现多个接口，而只能继承一个抽象父类。
接口与实现它的类不构成类的继承体系，即接口不是类体系的一部份。
因此，不相关的类可以实现相同的接口。
而抽象类是属于一个类的继承体系，并且一般位于类体系的顶层。
四、编程题
略
第五章异常处理
一、填空
1.面向对象、异常类
2.抛出异常、捕获异常
3.Throwable、Error、Exception
二、简答
1、答：
①异常是指程序发生了不正常的事件，例如，除数为零、需要的文件不存在、文件打不开、数组下标越界、内存不足等等。
②Java通过面向对象的方法来处理异常，引入了异常类。
每个异常类代表一类运行错误，类中包含了该运行错误的信息和处理错误的方法等内容。
每当Java程序运行过程中发生一个可识别的运行错误时，系统就会产生一个相应异常类的对象，并把它交给运行时系统，运行时系统寻找相应的代码来处理这一异常，以确保不会产生死机、死循环或其他刘操作系统有损害的结果，从而保证了整个程序运行的安全性。
2.答：
①相同点：
Error类和Exception类都是Throwable类的直接子类。
②不同点：
Error类，由系统保留，其定义了在正常情况下不能被程序捕获的所有异常；而Exception类则供应用程序使用，定义了一些在正常情况下可以被程序捕获且可能恢复的异常。
3.答：
将可能出现错误的程序代码放置try代码块中，当try代码块中产生异常时，可能会发生多种类型的异常，这时异常处理机制就会自动进行判断并寻找其参数与所发生异常的类型相匹配的第一个catch子句，然后由该子句负责处理该异常。
在try-catch-finally组合语句中，finally子句作为可选项，如果存在finally子句，不论try语句块中是否发生了异常，是否执行过catch子句，都需要执行finally子句。
一旦该子句执行结束，则整个异常处理程序就会中止，程序继续向下执行。
4.答：
①throw关键字主要用来显式地抛出异常，而throws关键字主要用来向方法的调用者传递异常，方法本身并不处理异常，由调用它的方法来处理这些异常。
三、编程
1、
importjava.io.IOException;
classArrayExceptionTest
{
publicstaticvoidmain（String[]args）
{
char[]data=newchar[5];
inti=0;
while（true）
{
try
{
data[i]=（char）System.in.read（）;
System.out.println（data[i]）;
}
catch（ArrayIndexOutOfBoundsExceptionaioobe）
{
aioobe.printStackTrace（）;
System.out.println（"数组越界，程序将终止！
"）;
}
catch（IOExceptionioe）
{
ioe.printStackTrace（）;
}
i++;
}
}
}
2、
classOnlyOneExceptionextendsException
{
OnlyOneException（）
{
super（"参数数目不符合运算要求，程序退出"）;
}
}
publicclassUserException{
publicstaticvoidmain（String[]args）{
try
{
if（args.length!
=2）
thrownewOnlyOneException（）;
floatopr1=Float.parseFloat（args[0]）;
floatopr2=Float.parseFloat（args[1]）;
System.out.println（opr1+"+"+opr2+"的结果为：
"+（opr1+opr2））;
}
catch（Exceptione）
{
e.printStackTrace（）;
}
}
}
第六章输入输出
一、填空
1.OutputStream、close（）
2.InputStream、in
3.FileOutputStream、FileInputStream
4.java.io.Reader、java.io.Writer、Unicode
二、简答
1.
答：
在Java语言中，输入和输出的操作是通过流来实现的。
流（Stream）是指数据在计算机各部件之间的流动，它包括输入流和输出流。
Java中提供了相应的字节流、字符流和过滤流。
2.
答：
①字节流是指数据源或目标中含有非字符数据，这些信息不能被解释成为字符，所以用字节流来输入输出。
例如：
InputStream类和OutputStream类是用来处理字节流的抽象基类。
②字符流是针对字符数据的特点进行过优化的，字符流的源和目的通常是文本文件，例如Reader和Writer是用来处理字符流的抽象基类。
③过滤流又叫处理流，其不直接与源或目标连接，而是与另外的流进行配合，对数据进行某种处理，例如BufferReader对另一个流产生的数据进行缓冲。
三、编程
1.
importjava.io.*;
publicclassStreamTest
{
publicvoidoutput（）
{
try
{
FileOutputStreamfos=newFileOutputStream（"myfile.txt"）;
fos.write（"Iamastudent".getBytes（））;
fos.close（）;
}
catch（IOExceptionioe）
{
ioe.printStackTrace（）;
}
}
publicvoidinput（）
{
try
{
InputStreamReaderisr=newInputStreamReader（newFileInputStream（"myfile.txt"））;
char[]data=newchar[100];
intlen=isr.read（data）;
System.out.println（"读取到得数据为:
"+newString（data,0,len））;
isr.close（）;
}
catch（IOExceptionioe）
{
ioe.printStackTrace（）;
}
}
publicstaticvoidmain（String[]args）
{
StreamTeststreamtest=newStreamTest（）;
streamtest.output（）;
streamtest.input（）;
}
}
2.
importjava.io.*;
publicclassBufferedStreamTest{
publicvoidoutput（）
{
try
{
FileOutputStreamfos=newFileOutputStream（"myfile.txt"）;
BufferedOutputStreambos=newBufferedOutputStream（fos）;
bos.write（"Iamastudent".getBytes（））;
bos.close（）;
}
catch（IOExceptionioe）
{
ioe.printStackTrace（）;
}
}
publicvoidinput（）
{
try
{
InputStreamReaderisr=newInputStreamReader（newFileInputStream（"myfile.txt"））;
BufferedReaderbr=newBufferedReader（isr）;
Stringdata=br.readLine（）;
System.out.println（"读取到得数据为:
"+data）;
br.close（）;
}
catch（IOExceptionioe）
{
ioe.printStackTrace（）;
}
}
publicstaticvoidmain（String[]args）
{
BufferedStreamTestbst=newBufferedStreamTest（）;
bst.output（）;
bst.input（）;
}
}
第七章多线程程序设计
一、简答题
1.答：
线程是进程内部的独立的，有序的指令流。
线程是比进程更小的执行单位，一个进程在其执行的过程中，可以产生多个线程。
2.答：
线程状态有五种：
新建、就绪、运行、阻塞和死亡。
进入阻塞状态的条件是：
（1）调用了sleep（）方法；
（2）线程要调用另一个对象的synchronized方法，但是还没有得到对象的锁；（3）为等候一个条件变量，线程调用wait（）方法；（4）输入/输出（I/O）流中发生线程阻塞。
3.答：
并发编程的优点是：
创建反应灵敏的用户界面；优化吞吐率；简化了"让一个程序同时做几件事"这个难题。
并发编程的缺点是：
等待共享资源的时候，运行速度会慢下来；线程管理需要额外的CPU开销；如果设计得不不合理，程序会变得异常复杂；会引发一些不正常的状态，像饥饿（starving），竞争（racing），死锁（deadlock），活锁（livelock）；不同平台上会有一些不一致。
比如在开发本书例子时发现，在有些平台下竞争很快就出现，但是换了台机器，它根本就不出现。
4.答：
创建线程有两种方法，第一种就是用类继承Java.lang.Thread类，并实现Thread类的ru
升级会员 