《JAVA大学实用教程》(第四版)课后习题答案

第一章Java 语言概述

2.“java编译器将源文件编译为的字节码文件是机器码”这句话正确吗？答：不正确

3.j ava 应用程序的主类必须含有怎样的方法？

答：含有main 方法

4。“java 应用程序必须有一个类是public 类”这句话正确吗？

答;不正确，只能有一个public 类

5。“java Applet 程序的主类必须是public 类”这句话正确吗？

答：正确，因为java Applet 主类必须是Applet 类的子类并且是public 的类6。请叙述java 源程序的命名规则。

答：与public 的类同名。

7。源文件生成的字节码文件在运行时都加载到内存中吗？

答：非也，动态随需要运行才加载。

8.面向对象的程序设计语言有那些基本特征？

答：封装；继承；多态性。

9.在Java 程序中有多个类文件时，用Java 命令应该运行那个类？

答：具有main 方法的类

第二章基本数据类型和数组

4。下列哪些语句是错的？

Int x=120；

Byte b=120；

b=x；

答：B=x；错应为b=（byte）x

5。下列哪些语句是错的？

答：y=d；错，应y=（float）d

6。下列两个语句是等价的吗？

Char x=97;

Char x=‘a’;

答：是等价的。

7。下列system.out.printf 语句输出结果是什么？

Int a=97;

Byte b1=(byte)128;

Byte b2=(byte)(-129);

System.out.printf(“%c,%d,%d”,a,b1,b2);

如果输出语句改为：

System.out.printf(“%d,%d,%d”,a,b1,b2);

输出什么？

答：输出a ，-128，127

修改后输出97，-128，127

8.数组是基本数据类型吗？怎样获取数组的长度？

答：不是基本数据类型，是复合数据类型。可以通过：数组名.length 的方法获得数组长度9。假设有两个int 类型数组：

Int[] a=new int[10]；

Int[] b=new int[8]；

b=a；

A[0]=100;

B[0]的值一定是100 吗？

答；一定，因为a 数组与b 数组引用相同。

10。下列两个语句的作用等价吗？

Int[] a={1，2，3，4，5，6，7，8}；

Int[] a=new int[8];

答：不等价，前者有初值，后者指分配空间。初值数组元素为0

11.有语句：

int [] a={1,2,3},b={4,5};

a=b;

求a[0]=? b[1]=? 为什么？

答：a[0]=4 ; b[1]=5 因为有相同的引用，同指向b[].

12.Java 语言使用____ _编码，每个字符占___ _ _ 字节__byte 位Unicode 2 16

第三章运算符、表达式与语句

1。下列语句输出的结果是什么？

Int a=100, x,y;

X=++a;

Y=a--

Sy stem.out.printf(“%d, %d,%d”,x,y,a);

答：101，101，100

2。下列语句那些有错误?

Int x=0;

X=5.0/2;

Float y=12.5F;

y=5.0/2;

答：x=5.0/2; 错。

3。下列语句那些有错？

Byte x=32;

Char c=‘a’;

Int n=c-x;

c=c-x;

答：c=c-x；错应为int 类型。

4 下列语句正确的是

A.表达式“12+56>34”的值是true

B.表达式“12+56||34”是非法表达式

C.表达式“x+y=12”是非法表达式

D.表达式“12+56>34”的值是13

答：（A, C ）

5。对于整数m，m<<1 的结果一定是2m 吗？

答：不一定，高位有损失时，不是2m

6.对于两个int 整形变量

Int m=120, n=240;

那么m^m=?;

m^n^n=?

答：m^m=0; m^n^n=120

7.下列System.out.printf 语句输出的结果是什么？

Int x=10, y=10, z=10;

If(x>9){

y=100;

Z=200;

}

Else

y=-100;

z=-200;

System.out.printf(“%d,%d,%d”,x,y,z);

输出：10，100，-200

8.下列for 语句输出结果是什么？

For(int i=1; i<=4;

i++){ Switch(i){

Case 1: System.out.printf(“%c”,’a’);

Case 2: System.out.printf(“%c”,’b’);

Break;

Case 3: System.out.printf(“%c”,’c’);

Case 4: System.out.printf(“%c”,’d’);

Break;

}

}

输出：a,b, b,c,d,d

9.下列System.out.printf 语句输出的结果是什么？Char a[]={‘a’,’b’,’c’,’d’,’e’};

For(i=0; i<=a.length/2; i++)

{

char c=a[i];

a[i]=a[a.length-(i+1)];

a [a.length-(i+1)]=c;

}

System.out.printf(“%c%c%c%c%c”a[0],a[1],a[2],a[3],a[4]);输出：e,d,c,b,a

10.下列System.out.printf 语句输出的结果是什么？

int a[]={3,4,1,2,-6};

for(int i=0;

i

j=i+1;j

if(a[j]

Int n=a[j]; a[j]=a[i]; a[i]=n;} } }

System.out.printf(“%d,%d,%d,%d,%d”,a[0],a[1],

a[2],a[3],a[4]);

输出：-6,1,2,3,4

11.public class Tick

{

public static void main(String args[])

{int a[]={3,4,1,2,-6};

for(int i=0;

i

j=i+1;j

if(a[j]

int n=a[j]; a[j]=a[i]; a[i]=n;} } }

System.out.printf("%d,%d,%d,%d,%d",a[0],a[1],

a[2],a[3],a[4]);

}

}

第四章类与对象

1.在声明类时，类名应遵循哪些习惯？

答：首字母大写，望名知意

2.类体内容有哪两种重要成员？

答：成员变量，和成员方法。

3。实例方法可以操作类变量吗？类方法可以操作实例变量吗？

答：实例方法可以操作类变量。

而类方法不可以操作实例变量。

4.当类的字节码加载到内存时，类变量就一定分配了内存空间吗？

答：实例成员变量不分配内存，而类变量一定分配内存。

5.类的实例变量在什么时候分配内存？

答:声明之后，在用new 关键字创建实例的时候才分配内存。

6.一个类的类变量被该类创建的所有对象共享吗？

答：共享

7.不同对象的实例变量分配的内存地址一定不同吗？

答：当出现引用赋值语句时两个实例变量的内存地址相同。

8.什么叫方法的重载？构造方法可以重载吗？

答：方法的重载是指一个类中可以有多个方法具有相同的名字，但这些方法的参数不同，或者参数的个数不同，或者参数的类型不同。构造方法可以重载。

9.请阐述为什么类方法不能调用实例方法？

答：对于类方法在该类加到内存时就分配了相应的入口地址，所以即使该类未创建对象，也可以通过类名调用类方法。而这时在类对象创建之前，实例方法还没有入口地址。还不知道一个方法从何处开始执行，当然不能调用。

10.请阐述，为什么类方法中不能操作实例成员变量？

答：对于类方法在该类加到内存时就分配了相应的入口地址，所以即使该类未创建对象，也可以通过类名调用类方法。而这时在类创建之前，实例成员变量还没有分配内存空间。没内存空间当然无法操作。

11.实例方法可以用类名直接调用吗？

答：不能，因为实例方法，用new 创佳对象后才分配入口地址，而类名，一经声明就分配类名地址。而这时对象创建之前实例方法还没有入口地址。实例方法表现实例的功能，或改变实例变量。用类调用改变那个实例的实例变量，表现那个实例的功能，不明确。

12.关键字this 可以出现在构造方法中吗？可以出现在实例方法中吗？可以出现在类方法中吗？

答：可以出现在构造方法中，代表该类构造方法所创造出的对象。可

以出现在实例方法中，代表使用该方法的当前对象。

This 不能出现在类方法中，因为类方法是通过类名调用的。

13.源文件声明编写的类一定在同一个包中吗？

答：不一定，当不在同一包中时，可用import 语句将其所在的包引入该源文件中。

14.“import java.awt.*”与“import java.awt.Button”有什么不同？

答：前者引入了awt 包中的所有类，后者只引入了Button 一个类。

15.程序中使用了“import java.util.*;”程序运行时，是要加载java.util 包中的全部类到内存吗？

答：不，只加载本程序用到的类到内存中，因为java 程序是动态加载，字节码类文件。16.有哪几种访问权限修饰符？说出一种的作用。

答：访问权限修饰符有public, private,protected.

Private 作用是只允许本类的对象访问。

17.怎样反编译一个类？

答:使用SDK 提供的反编译器javap.exe 文件可以实现将字节码文件反编译为源码文件。可查看源码中public 方法和public 成员变量的名字。

如加入参数-private 则可列出其全部的成员方法和成员变量。

如：

Javap –private java.awt.Button 则可以列出Button 类中全部的方法和成员变量。

18.下面程序中那个语句是错的？

class A

{

private float weight; //weight 被修饰为private 的float 型变量。

public float f(float a,float b) //方法f 是public 方法。

{ return a; } }

public class B

{

void g()

{

A a=new A();

a.weight=23f;

a.f(3,4);

} }

答：a.weight=23f;错

1.编写一个类，该类创建的对象可以计算等差数列的和。

解：class DengCha{

int start,d;

DengCha(){

}

DengCha(int start,int

d){ this.start=start;

this.d=d;

}

void setStart(int

s){ start=s;

}

void setD(int

d){ this.d=d;

}

int getSum(int

n){ int

sum=0,i=1;

while(i<=n){

sum=sum+start;

start=start+d;

i++;

}

return sum;

}

}

public class ZuoYe04_1

{

public static void main (String args[ ])

{

DengCha shulie=new DengCha(2,3);

System.out.println(shulie.getSum(100));

shulie.setStart(10);

shulie.setD(5);

System.out.println(shulie.getSum(9));

DengCha arithmetical=new DengCha();

Scanner Reader=new Scanner(System.in);

System.out.println("请输入等差数列开始值");

arithmetical.start=Reader.nextInt();

System.out.println("请输入等差数列的差值");

arithmetical.d=Reader.nextInt();

System.out.println("请输入等差数列求和的个数");

int n=Reader.nextInt();

System.out.println(n+"个数的和是"+arithmetical.getSum(n));

}

}

3.编写一个类，该类封装了一元二次方程的属性和功能，即该类有刻画方程系数的3 个成员变量和求根的方法。要求：该类所有对象共享常数项。

class

SquareEquation{ d

ouble a,b;

static double c;

double root1,root2;

boolean boo;

public SquareEquation(double a,double b,double

c){ this.a=a;

this.b=b;

SquareEquation.c=c;

if(a!=0){

boo=true;

}

else{

boo=false;

}

}

public void

getRoots(){ if(boo){

System.out.println("是一元2 次方程");

double disk=b*b-4*a*c;

if(disk>=0){

root1=(-b+Math.sqrt(disk))/(2*a);

root2=(-b-Math.sqrt(disk))/(2*a);

System.out.printf("方程的根:%f,%f\n",root1,root2);

}

else{

System.out.printf("方程没有实根\n");

}

}

else{

System.out.println("不是一元2 次方程");

}

}

public void setCoefficient(double a,double b,double

c){ this.a=a;

this.b=b;

SquareEquation.c=c;

if(a!=0){

boo=true;

}

else{

boo=false;

}

}

}

public class ZuoYe4_3{

public static void main(String args[ ]){

SquareEquation equation1=new SquareEquation(4,5,1);

SquareEquation equation2=new SquareEquation(3,5,-7);

equation1.getRoots();

equation2.getRoots();

}

}

4.程序源文件Example.java 如果使用了包语句，例如：

package tom.jiafei;

并且有c:\1000\tom\jiafei 的目录结构，并且将源文件编译后得到的全部字节码文件拷贝到目录c:\1000\tom\jiafei 中。问在哪个目录中运行此文件，运行命令是什么？

答：运行程序时必须到tom\jiafei 的上一层目录1000 中来运行，如：

c:\1000\java tom.jiafei. Example

第五章继承、接口与泛型

1。子类在什么情况下可以继承父类的友好成员？

答：父子类在同一包中时子类可以继承父类的友好成员。

2。子类通过什么办法，可以隐藏继承的成员变量。

答：子类成员变量与父类成员变量同名。

3。子类重写继承方法的规则是什么？

答：重写隐藏父类的方法需：返回的数据类型相同，参数的个数相同，并且类型相同。如

果重写父类的方法后参数的个数或类型不同会出现子类方法的重载。

4.子类的构造方法的第一条语句是什么？

答：如果需要调用父类构造方法，则应是用super 关键词调用父类的构造方法。

5。子类一旦重写了继承的方法，就会隐藏继承的方法。是这样吗？

答：不一定。在参数的个数或类型不同时会产生重载。如果只有返回值的类型不同，将会产生编译错误。

(5)子类隐藏父类的方法，参数必须______相同并且_ _ 相同.

答：个数，类型

6。子类重写继承方法时，可以降低方法的权限吗？

答：重写继承方法时不能降低访问权限。

7。简述关键字super 的用法。

答：1）子类调用父类的构造方法。

2）子类对象引用被隐藏了的父类方法，或成员变量。

8.假设父类有一个方法：

Public double f(double x, double

y){ return x+y;

}

是否允许子类再声明如下的方法：

Public float f(double x, double

y){ return 23;

}

答：不允许。

9。父类的final 方法可以被子类重写吗？

答：不可以

10。什么类中可以有abstract 方法？

答：被abstract 修饰的类。接口中也可以有abstract 方法

11。什么叫做对象的上转型对象？

答：用子类的构造方法构造出来的对象，赋值给父类对象。

12。什么叫接口回调？

答：用实现接口的类创建的对象，赋值给该接口声明的接口变量。

13。与类有关的匿名类一定是该类的子类吗？与接口有关的匿名类一定是实现该接口的一个类吗？

答：一定，因为类创建对象时，除了构造方法还有类体，此类体被认为是该类的一个子类去掉类声明后的类体。即匿名类，匿名类就是一个子类。与接口的匿名类相同。一定是子类。

14。怎样声明一个泛型类？

答：我们可以这样声明一个泛型类：

class A 其中A 时泛型的名称，E 是其中的泛型，即我们没有指定E 是何种类型的数据，它可以是任何对象或接口，但不能是基本数据类型。

15 阅读下列程序，并说明输出结果。

class NegativeIntegerException extends

Exception{ String message;

public NegativeIntegerException(){

message="方法的参数值不是正整数";

}

public String

toString(){ return

message;

}

}

class MaxCommonDivisor{

public int getMaxCommonDivisor(int a, int b)throws

NegativeIntegerException{ if(a<0||b<0)

throw new NegativeIntegerException();

int r=0;

if(a>b){

int t=a; a=b; b=t;

}

r=a%b;

while(r!=0){

a=b;

b=r;

r=a%b;

}

return b;

}

}

class MinCommonMultiple extends MaxCommonDivisor{

public int getMinCommonMultiple(int a, int b)throws NegativeIntegerException{

if(a<0||b<0)

throw new NegativeIntegerException();

int y=0;

int x=getMaxCommonDivisor(a,b);

y=(a*b)/x;

return y;

}

}

public class Example{

public static void main (String arg[]){

int maxCommonDivisor, minCommonMultiple;

MaxCommonDivisor max=new MaxCommonDivisor();

MinCommonMultiple min = new MinCommonMultiple();

try{

maxCommonDivisor=max.getMaxCommonDivisor(18,12);

System.out.println("最大公约数："+ maxCommonDivisor);

minCommonMultiple=min.getMinCommonMultiple(18,12);

System.out.println("最小公倍数："+minCommonMultiple);

maxCommonDivisor=max.getMaxCommonDivisor(-64,48);

System.out.println("最大公约数："+maxCommonDivisor);

}

catch(NegativeIntegerException

e){ System.out.println(e.toString());

}

}

}

3。编写一个类要求实现一个接口，该接口有3 个abstract 方法：

Public abstract void f( int x);

Public abstract void g(int x, int y);

Public abstract double h(double x);

要求在应用程序主类中使用该类创建对象，并使用接口回调调用方法f(), g() 和h().

解：

interface A{

public abstract void f(int x);

public abstract void g(int x,int y);

public abstract double h(double x); }

class A1 implements

A{ public void f(int

x){

System.out.println(x);

}

public void g(int x,int

y){ int z=x+y;

System.out.println(z);

}

public double h(double

x){ return x*x;

}

}

class A2 implements

A{ public void f(int

x){

System.out.println("Hello:"+x);

}

public void g(int x,int

y){ int z=x-y;

System.out.println(z);

}

public double h(double

x){ return

Math.sqrt(x);

}

}

class A3 implements

A{ public void f(int

x){

System.out.println("你好:"+x);

}

public void g(int x,int

y){ double

z=(double)x/y;

System.out.println(z);

}

public double h(double

x){ return 1/x;

}

}

public class ZuoYe5_3{

public static void main(String

args[ ]){ A a=new A1();

a.f(10);

a.g(12,20);

System.out.println(a.h(100));

a=new A2();

a.f(10);

a.g(12,20);

System.out.println(a.h(100));

a=new A3();

a.f(10);

a.g(12,20);

System.out.println(a.h(100));

}

}

利用面向接口编程的方法，编写计算锥形体积的完整程序，注意锥形的底可以为圆形，矩形，或梯形等。（对细节满足开闭原则。）

4 求下列程序运行结果：

class A{

public double y=11.456789;

public void f(){

y=y+1;

System.out.printf("y 是double 型的变量,y=%f\n",y);

}

}

class B extends

A{ int y=0;

public void

g(){ y=y+1

00;

System.out.printf("y 是int 型的变量,y=%d\n",y);

}

}

class Example5_3{

public static void main(String

args[ ]){ B b=new B();

b.y=200;

b.g(); //调用子类新增的方法

b.f(); //调用子类继承的方法

}

}

5.求下列程序运行结果

class A{

int m=0,n=0;

long f(){

return m+n;

}

}

class B extends

A{ int m=1,n=1;

long f(){

long result=0;

super.m=10;

super.n=20;

result=super.f()+(m+n);

return result;

}

long g(){

long result=0;

result=super.f();

return result/2;

}

}

public class Example5_7{

public static void main(String

args[ ]){ B b=new B();

b.m=3;

b.n=7;

long resultOne=b.g();

long resultTwo=b.f();

long resultThree=b.g();

System.out.println("resultOne="+resultOne);

System.out.println("resultTwo="+resultTwo);

System.out.println("resultThree="+resultThree);

}

}

(6)即所谓的开闭原则，对_____ 关闭，对_ __________ 开放。

答：修改，扩展

（7）编写一个面向抽象的完整程序，求柱形体积，计算方法底*高，但底面积的算法经常要变化。于是对于求底面积可以设一个抽象类Geometry 。柱形面对具有抽象类的Geometry 设计。最后完成对圆形底面积的柱形，和梯形底面积的柱形计算体积。

（8）求下列程序的运行结果。

interface Show{

void show();

}

class A implements

Show{ public void

show(){

System.out.println("I love This Game");

}

}

class B implements

Show{ public void show(){

System.out.println("我喜欢看NBA");

}

}

class C{

public void f(Show s){ //接口作为参数

s.show();

}

}

public class Example5_13{

public static void main(String

args[]){ C c=new C();

c.f(new A());

c.f(new B());

}

}

答：I love This Game

我喜欢看NBA

(9)写出下面程序的运行结果：

public class Example5_18{

public static void main(String

args[ ]){ int n=0,m=0,t=0;

try{

}t=9999;

m=Integer.parseInt("8888");

n=Integer.parseInt("12s3a"); //发生异常，转向catch System.out.println("我没有机会输出");

catch(Exception e){

System.out.println("发生异常");

n=123;

}

System.out.println("n="+n+",m="+m+",t="+t);

}

}

答：发生异常n=123, m=8888, t=9999

1。对于字符串

第六章字符串和正则表达式

String S1=new String(“OK”);

String S2=new String(“OK”);

说出下列表达式的值：

S1==S2

S1.equals(S2)

答：（1）false(2)true

2.对于字符串

String s1=new String(“I love you zhht”);

String s2=s1.replaceAll(“love”,”hate”);

说出System.out.printf(“%s, %s”, s1,s2)的结果。

结果：I love you zhht , I hate you zhht

3.String 类和StringBuffer 类有何不同？

答：String 类创建的字符串对象存储空间是不能修改的。

而使用StringBuffer 类创建的对象是可以修改其字符串序列，即该类的对象的实体内存空间是可以改变的，便于存放可变字符串。

4。对于StringBuffer 串

StringBuffer str=new StringBuffer(“abcdefg”);

str=str.delete(2,4);

说出System.out.println(str)的结果。

答：abefg (4 为需要删除的下一个字符的下标)

5.StringTokenizer 类的主要用途是什么？该类有哪几个重要的方法？

答：当我们分析一个字符串并将字符串分解成可被独立使用的单词时，可以使用java.util 包中的StringTokenizer 类.

可以使用nextToken()方法逐个获取字符串分析器中的语言符号（单词），每当获取到一个语言符号，字符串分析器中的负责计数的变量的值就自动减一，该计数变量的初始值等于字符

串中的单词数目.

字符串分析器调用countTokens()方法可以得到计数变量的值。

字符串分析器通常用while 循环来逐个获取语言符号，为了控制循环，我们可以使用StringTokenizer类中的hasMoreTokens()方法，只要计数的变量的值大于0，该方法就返回true，否则返回false。

6。下列System.out.printf 语句的输出结果是什么？

String s=new String(“we, go, to, school”);

StringTokenizer token=new StringTokenizer(S,”,”);

String word=token.nextToken();

Int n=token.countTokens();

System.out.printf(“%s,%d”,word,n);

答：We ，3

7。请说出Matcher 对象的find()方法和lookingAt()方法有什么不同？

答：public boolean find() ：寻找input 和pattern 匹配的下一子序列

public boolean lookingAt()：判断从input 的开始位置是否有和pattern 匹配的子序列。

8。正则表达式中的元字符[123]代表什么意思？

答：代表1，2，3 中的任何一个

9。说出与模式“A[125]{2}”匹配的4 个字符串。

答：A12，A25，A15，A52

10。下列哪些字符串匹配模式“boy\\w{3}”

boy111 B. boy!@#

C. Boyweo

D. Boyboybpy

答：C。boyweo A.boy111

11.有模式pattern=“A[1359]?”

求和模式pattern 相匹配的全部字符串？

答：“A”, “A1”, “A3”, “A5”, “A9”

12.一个正则表达式是含有一些具有____ ______ 的字符串，这些特殊字符称作正则表达式中的_ ___

答：特殊意义字符, 元字符

第七章常用实用类

1.怎样实例化一个Calendar 对象？

答：Calendar 类在java.util 包中。使用Calendar 类的static 方法getInstance()可以初始化一个日历对象，如：

Calendar calendar= Calendar.getInstance();

2.Calendar 对象调用set(1949, 9,1)设置的年月日分别是多少？

答：1949 年10 月1 日

3.怎样得到一个1--100 之间的随机数？

答：int randomNumber=(int)(Math.random()*100)+1

4.BigInteger 类的常用构造方法是什么？

答：可以使用构造方法：public BigInteger(String val)

5.两个BigInteger 类对象怎样进行加法运算？

答：BigInteger n1=new BigInteger ("大整数字符串"),

n2=new BigInteger("大整数字符串"),

result=null;

result=n1.add(n2);

6.LinkedList泛型类是一种什么数据结构？

答：是一种链表类数据结构。

7.对于需要经常查找的数据，应选用LinkedList还是选用HashMap?

答：选用HashMap

第八章线程

1.线程和进程是什么关系？

答：线程是比进程更小的执行单位。一个进程在其执行过程中，可以产生多个线程，形成多条执行线索，每条线索，即每个线程也有它自身的产生、存在和消亡的过程，也是一个动态的概念。

2.线程有几种状态？

答：新建状态，运行状态，中断状态，死亡状态

3.引起线程中断的常见原因是什么？

答：有4 种：有4 种原因的中断：

（a）JVM 将CPU 资源从当前线程切换给其他线程，使本线程让出CPU 的使用权处于中断状态。

（b）线程使用CPU 资源期间，执行了sleep(int millsecond)方法。

（c）线程使用CPU 资源期间，执行了wait()方法。

(d) 线程使用CPU 资源期间，执行某个操作进入阻塞状态，比如执行读/写操作引起阻塞。

4.一个线程执行完run（）方法后，进入什么状态？该线程还能再调用start（）方法吗？答：一个线程执行完run（）方法进入死亡状态，之后还能再调用start（）方法运行

5.线程在什么状态时，调用isAlive()方法后返回值是false？

答:当线程进入死亡状态后（实体内存被释放），线程仍可以调用方法isAlive（），这时返回的值是false。（线程未调用start 方法之前，调用isAlive()方法返回false).

6.线程调用interrupt()的作用是什么？

答：intertupt 方法经常用来“吵醒”休眠的线程。当一些线程调用sleep 方法处于休眠状态时，一个使用CPU 资源的其它线程在执行过程中，可以让休眠的线程调用interrupt 方法“吵醒”自己，即导致休眠的线程发生InterruptedException 异常，从而结束休眠，重新排队等待CPU 资源。

8.wait(), notify(), notifyAll()的作用分别是什么？

答：wait（）、notify（）和notifyAll（）都是Object类中的final方法，被所有的类继承，且不允许重写的方法。

当一个线程使用的同步方法中用到某个变量，而此变量又需要其它线程修改后才能符合本线程的需要，那么可以在同步方法中使用wait（）方法。使用wait（）方法可以中断方法的执行，使本线程等待，暂时让出CPU 的使用权，并允许其它线程使用这个同步方法。其它线程如果在使用这个同步方法时不需要等待，那么它使用完这个同步方法的同时，应当用

notifyAll（）方法通知所有的由于使用这个同步方法而处于等待的线程结束等待。(如果使用notify()方法则只通知处于等待中的某一个线程结束等待)

9.将例子10 中的TicketSeller 类中的循环条件：

While(fiveNumber<1)

改写成：

If(fiveNumber<1)是否合理，理由是什么？

答：是合理的，因为此循环只有一种可能作循环体内的语句。

10.将例子10 中的TicketSeller 类中出现的：

Wait( )

改写成：

Thread.sleep(2000)从新编译，运行，观察结果。

答：sleep(2000)线程到时醒来排队，这期间中断的原因不一定解决，wait()则直到中断原因消失才结束等待。

11.什么叫守护线程？

答：一个线程调用

void setDaemon(boolean on)

方法可以将自己设置成一个守护（Daemon）线程，例如：

thread.setDaemon(true);

线程默认是非守护线程，非守护线程也称作用户（user）线程。

当程序中的所有用户线程都已结束运行时，即使守护线程的run 方法中还有需要执行的语句，守护线程也立刻结束运行。一般地，用守护线程做一些不是很严格的工作，线程的随时结束不会产生什么不良的后果。一个线程必须在运行之前设置自己是否是守护线程。

12.对于thread(Runnable target)构造的线程使用同一目标对象的线程，目标对象的成员变量自然成为这些线程____ ________ 的数据单元。

答：共享

第九章输入、输出流

1.如果准备读取一个文件应使用FileInputStream 流还是使用FileOutputStream 流？

答：FileInputStream

2.FileInputStream 流的read()方法和FileReader 流的read()方法有什么不同？

答：FileInputStream 流从输入流中顺序读取单个字节的数据。该方法返回字节数据值（0 - 255 之间的整数）到末尾返回-1

FileReader 流，输入流调用该方法从源中读取一个字符，该方法返回一个0 -- 65535 之间的一个整数（Unicode 字符值）到末尾返回-1 。

3.BufferReader 流能直接指向一个文件对象吗？

答：不能，要通过一个，底层的FileImputStream 类的对象，才能指向一个文件对象。

4.ByteArrayOutputStream 流怎样获取缓冲区中的内容？

答：这个流的对象可以通过public byte[ ] toByteArray( )方法，将刚刚写入缓冲区的内容全部返回。

5.DataInputStream 类和DataOutputStream 类的主要用途是什么？

答：主要是将java 基本数据类型写入底层流或以Java 基本数据类型的方式读出底层流的内容。

6.使用ObjectInputStream 类和ObjectOutputStream 类有哪些注意事项？

答：值得注意：当用对象流写入或读出对象时，要保证对象是序列化的。这是为了保证能把对象写到文件，并能再次把对象正确读回到程序中。

Java 提供给我们的绝大多数对象都是所谓序列化的，比如组件等。一个类如果实现了Serializable 接口，那么这个类创建的对象就是所谓序列化的对象。Serializable 接口中的方法对程序是不可见的，因此实现该接口的类不需要实现额外的方法，当把一个序列化的对象写入到对象输出流时，JVM 就会实现Serializable 接口中的方法，按着一定格式的文本将对象写入到目的地。

7.怎样使用输入/输出流技术克隆对象？

答：使用对象流很容易得获取一个序列化对象的克隆。我们只需将该对象写入到对象输出流，然后用对象输入流读回的对象就是原对象的一个克隆。

如：Shop shop1=new Shop();

Goods s1[]={new Goods("TV"),new G oods("PC")};

shop1.setGoods(s1);

try{ ByteArrayOutputStream out=new ByteArrayOutputStream();

ObjectOutputStream objectOut=new ObjectOutputStream(out);

objectOut.writeObject(shop1);

ByteArrayInputStream in=new ByteArrayInputStream(out.toByteArray());

ObjectInputStream objectIn=new ObjectInputStream(in);

Shop shop2=(Shop)objectIn.readObject();

Shop2 就是shop1 的克隆。

8.使用RandomAccessFile 类读写文件的好处是什么？

答(1)用这个类创建的流对象，建立的流既可以象文件写，也可以从同一文件读出。

(2)可以将读取文件，或写入文件的任意位置。

9.使用RandomAccessFile 类创建的流______ 输入流，__ _输出流。

答：既不是，也不是

10.经常使用File 类的对象获取文件本身的一些信息，但不可以获得文件的____ _

答：内容