Java程序设计各章习题及其答案

第一章 习题及思考题

1、 Java程序是由什么组成的？一个程序中必须有public类吗？Java源文件的命名规则是怎样的？

答：一个Java源程序是由若干个类组成。一个Java程序不一定需要有public类：如果源文件中有多个类时，则只能有一个类是public类；如果源文件中只有一个类，则不将该类写成public也将默认它为主类。源文件命名时要求源文件主名应与主类（即用public修饰的类）的类名相同，扩展名为.java。如果没有定义public类，则可以任何一个类名为主文件名，当然这是不主张的，因为它将无法进行被继承使用。另外，对Applet小应用程序来说，其主类必须为public，否则虽然在一些编译编译平台下可以通过（在BlueJ下无法通过）但运行时无法显示结果。

2、怎样区分应用程序和小应用程序？应用程序的主类和小应用程序的主类必须用public修饰吗？

答：Java Application是完整的程序，需要独立的解释器来解释运行；而Java Applet则是嵌在HTML编写的Web页面中的非独立运行程序，由Web浏览器内部包含的Java解释器来解释运行。

在源程序代码中两者的主要区别是：任何一个Java Application应用程序必须有且只有一个main方法，它是整个程序的入口方法；任何一个Applet小应用程序要求程序中有且必须有一个类是系统类Applet的子类，即该类头部分以extends Applet结尾。 应用程序的主类当源文件中只有一个类时不必用public修饰，但当有多于一个类时则主类必须用public修饰。小应用程序的主类在任何时候都需要用public来修饰。

3、开发与运行Java程序需要经过哪些主要步骤和过程？

答：主要有三个步骤 （1）、用文字编辑器notepad（或在Jcreator,Gel, BuleJ,Eclipse, Jbuilder等）编写源文件； (2)、使用Java编译器（如Javac.exe)将.java源文件编译成字节码文件.class；

(3)、运行Java程序：对应用程序应通过Java解释器（如java.exe)来运行，而对小应用程序应通过支持Java标准的浏览器(如Microsoft Explorer)来解释运行。

4、安装JDK之后如何设置JDK系统的PATH，CLASSPATH？他们的作用是什么？

答、更新系统PATH的方法随Windows版本不同而不同。对于Windows 95/98，可以将下列项目作为C:\\autoexec.bat文件的最后一行：

SET PATH = C:\\j2sdk1.4.2\\bin;%PATH%

当程序需要第三方的类库支持, 而且比较常用, 就可以采用此种方法.比如常用的数据库驱动程序, 写 servlet 需要的 servlet 包等等. 设置方法就是在环境变量中加入 CLASSPATH. 然后就可以直接编译运行了.Java运行环境从CLASSPATH环境变量中寻找要执行的用户项目（三方的类库）。可以按如下的方式设置

SET CLASSPATH=.;C:\\J2SDK1.4.2\\jre\\lib\\jaws.jar;%CLASSPATH%

通常我们要从当前目录中寻找用户类，因为开发的程序相关的类放在这里,. 表示当前工作目录.

5、Java语言特点是什么？

答：Java是一种简单的面象对象的分布式的解释的健壮的安全的结构中立的可移植的性能很优异的多线程的动态的语言。

6、简述面向过程问题求解和面向对象问题求解的异同。试列举出面向对象和面向过程的编程语言各两种。

解：面向过程问题求解利用计算机能够理解的离散逻辑来描述和表达所求解的问题本身以及具体问题解决的过程，它的核心是算法和数据结构，面向对象的问题求解则利用符合人们日常思维习惯的方式去模拟所求解的问题，模拟它的构成、特征和各种动态行为，从而得到问题的解答。它的核心是类、对象和设计模式。

常见的面向过程的编程语言有BASIC，FORTRAN，Pascal, C等。常见的面向对象的编程语言有Smalltalk-80,Object Pascal, C++, Java等。

第二章 习题及思考题

1. 试分析基本数据类型和引用数据类型的基本特点？

答：Java的基本数据类型都有固定的数据位，不随运行平台的变化而变化。 引用类型都是用类或对象实现的

2. 请使用异或运算符^, 实现两个整数的交换。 答：int x=5,y=19; x=x^y; y=y^x; x=x^y;

3. 下列哪个是合法的标识符：( )。

A、a=b B、_Hello C、2nd D、Chong qing 答：B

4. 下列哪些是合法的标识符（）。

A、new B、class C、int D、const2 答：D

5. 如果定义有变量double d1, d2=4.0则下列说法正确的是：

A、变量d1,d2均初始化为4.0

B、变量d1没有初始化,d2初始化为4.0 C、变量d1,d2均未初始化

D、变量d2没有初始化,d1初始化为4.0

答：B

6. 判断题：所有的变量在使用前都必须进行初始化。（ ） 答：正确。

7. 内部数据类型byte的取值范围是：( )

A、0～65, 535 B、(-128)～127

C、(-32,768)～32,767 D、(-256)～255 答：B

8. 下列哪些是不能通过编译的语句：（ ）

A、int i = 32; B、float f = 45.0;

C、double d = 45.0; D、char a=‘c’; 答： B

9. 判断题：Java中数据类型的长度与具体使用的机器相关。（ ） 答：错误。

10. 如果定义有double x；float y；int m,则表达式x*y-m的类型为（ ）：

A、double B、float C、int D、short 答：A

11. 如果定义有short s；byte b；char c,则表达式s*b+c的类型为（ ）：

A、char B、short C、int D、byte 答：C

12. 已知int i= 2147483647; ++i； 则i的值等于多少（ ） A -2147483648 B 2147483647 C 2147483648 答：A

13. 已知byte i= 127; ++i； 则i的值等于多少（ ） A -128 B 127 C 128 答：A

14. 已知byte i= 127; i=i+1；这两行语句能否编译成功？（ ） 答：编译不成功。

15. 执行以下程序段int a=5,b; b=++a*3后b的值为：（ ）

A、17 B、18 C、16 D、15 答： B

16. 如果x=3,y=5,则表达式x|y的值为：（ ）

A、15 B、8 C、1 D、7 答：D

17. 如果int a=3,b=2,则执行a*=b+8后a的值为：（ ）

A、20 B、14 C、30 D、16 答：C

18. 若所用变量都已正确定义，以下选项中，非法的表达式是：（ ）

A、a!=4||b==1 B、'a'%3 C、'a'=1/2 D、'A'+32 答：C

19. 设有定义语句int a[]={1,1,2}; 则以下对此语句的叙述错误的是( )。

A、定义了一个名为a的一维数组 B、a数组有3个元素

C、a数组的下标为1～3 D、数组中的每个元素是整型 答：C

20. 以下数组初始化形式正确的是：( )

A、int t1[][]={{1,2},{3,4},{5,6}} B、int t2[][]={1,2,3,4,5,6} C、int t3[3][2]={1,2,3,4,5,6} D、int t4[][];t4={1,2,3,4,5,6} 答：A

第三章 习题及思考题

1、编写一个程序，用选择法对数组a[]={20,10,55,40,30,70,60,80,90,100}进行从大到小

的排序

解： public class ArraySort{

public static void main(String args[]){

int array[]={20,10,55,40,30,70,60,80,90,100}; int i,j,k,t;

int m=array.length; for(i=0;i

for(j=i+1;j

if(array[j]

t=array[k];array[k]=array[i];array[i]=t; }

for(i=0;i

System.out.println(\ } }

2、求两个整数的最大公约数 解public class Gcd_do {

public static void main(String args[]) {

int a=45,b=21,k=0;

System.out.print(\ do {

k = a % b; a = b; b = k;

} while (k!=0);

System.out.println(a); } }

3、请打印出如下九九乘法表

* | 1 2 3 4 5 6 7 8 9 -------|------------------------------------ 1 | 1 2 | 2 4 3 | 3 6 9

4 | 4 8 12 16 5 | 5 10 15 20 25 6 | 6 12 18 24 30 36 7 | 7 14 21 28 35 42 49 8 | 8 16 24 32 40 48 56 64 9 | 9 18 27 36 45 54 63 72 81

解：

public class MultiTable{

public static void main(String args[]) { int i,j,n=9;

System.out.print(\ for (i=1;i<=n;i++)

System.out.print(\ System.out.print(\ for (i=1;i<=n;i++)

System.out.print(\ System.out.println(); for (i=1;i<=n;i++) {

System.out.print(\ for (j=1;j<=i;j++)

System.out.print(\ System.out.println(); } } }

4、求一元二次方程ax2+bx+c=0的根,要求a、b、c从控制台输入。 mport java.io.*;

// import java.awt.*;

public class abcxxx {

public static void main(String args[]) throws IOException {

BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in)); String x; double a,b,c;

double x1,x2,p1,p2,disc,absdisc;

System.out.print(\ for(;true;) {

System.out.println(\ x=keyin.readLine();

a=Double.parseDouble(x); x=keyin.readLine();

b=Double.parseDouble(x); x=keyin.readLine();

c=Double.parseDouble(x);

System.out.println(\

if(a==0.0) { if(b!=0.0){

System.out.println(\ } else {

if(c==0.0)

System.out.println(\

else System.out.println(\ } } else {

p1=-b/(2.0*a); disc=b*b-4.0*a*c;

absdisc=disc>=0?disc:-disc; p2=Math.sqrt(absdisc)/(2.0*a); if(disc<0.0) {

System.out.println(\ }

else { x1=p1+p2; x2=p1-p2;

System.out.println(\ System.out.println(\ } }

} // endfor } }

5、求前40个Fibonacci数列。

Fibonacci数列：1，1，2，3，5，8，13，21，34，? 从数列看到：F1=1 (n=1) F2=1 (n=2) Fn=Fn-1+Fn-2 (n≥3) 解：

public class Fibonacci {

public static void main(String args[]) {

long f1,f2; int i; f1=1; f2=1;

System.out.println (f1+\

for (i=3;i<=20;i++) { f1=f1+f2; f2=f1+f2;

System.out.println (f1+\ } } }

6、已知公鸡5元1只，母鸡3元一只，小鸡1元3只，要求用100元刚好买100只鸡，问有多少种

采购方案。

解：public class Loop_Loop3_20

{ public static void main(String args[]) { int I,J,K;

System.out.println(\for (I=0;I<=20;I++ ) // I 为公鸡数 {

for ( J=0;J<=33;J++) // J 为母鸡公鸡数 {

K=100-I-J; // K 为小鸡数 if (5*I+3*J+K/3.0==100)

System.out.println(\ } } } }

7、判断一个字符串是否是回文，例如“rotor“反转之后还是”rotor“，所以是回文。需

查阅String类的一些方法。 解：

public class Rotor {

public static void main(String args[]) {

String str=\ int i=0,n;

boolean yes=true; if (args.length>0) str=args[0];

System.out.println(\ n=str.length(); char ch1,ch2; String temp=\ for (i=0;i

sub1=str.substring(i,i+1); temp=sub1+temp;

}

System.out.println(\ System.out.println(str+“ ：”+str.equals(temp)); } }

8、求2-1000内的所有素数 class prime

{ public static void main(String args[]) { int sum=0,i,j;

for( j=2;j<=1000;j++) //求50以内的素数 { for( i=2;i<=j/2;i++) {if(j%i==0) break; }

if(i>j/2)

{System.out.println(\是素数\ } } } }

9、在一个循环中使用break,continue和return有什么不同？

解：在循环中使用break语句，将使循环终止，流程从break语句处跳转到break语句所在的

循环外面的第一个语句继续执行。 在循环中使用continue语句，将提前结束本轮循环，流程跳转到continue语句所在循环的第

一个语句继续执行。

在循环中使用return语句，将终止当前方法调用，同时终止循环，使流程返回到调用语句的

下一个语句执行。

10、结构化程序设计有哪三种流程？他们分别对应Java中那些语句

解：结构化程序设计有三种基本流程：循环、分支和顺序。Java程序中的分支语句包含if

语句、switch语句；循环语句包括了while语句，do-while语句、for语句；其他语句如变量、对象定义、赋值语句、方法调用语句、以及上面的循环结构、分支结构等按照上下文排列都是顺序语句。

第四章 习题及思考题

1.什么是类？什么是对象？对象和类是什么关系？

答：类是抽取了同类对象的共同属性和行为形成的对象或实体的“模板”。 对象是现实世界中实体的描述，是其自身所具有的状态特征及可以对这些状态施加的操作结

合在一起所构成的独立实体。 类和对象之间的关系是抽象和具体的关系：类表达的是一种抽象的概念，它描述

了该类对象的共同特征；而对象是具体事物，以类为模板来生成，它具有自

己的状态。举例：类与对象的关系犹如零件的图纸与按图纸制造出的零件关系一样；图纸（类）描述了零件（对象）的共同特征，每个零件（对象）又有自己的个性，如加工精度的不同等等

2、 什么是方法？方法的结构是怎样的？设计方法应考虑哪些因素？ 答：方法是Java类的一个组成部分，通过类的方法改变对象的状态。 方法的结构：[方法修饰符] 返回值类型 方法名（[形参列表]）[throws异常列表] {

方法体；

}

设计方法应考虑因素有：

(1) 方法名是Java中任意的标识符，按照命名的约定，方法名应该是有意义的

动词或动词短语，它的第一个字母一般要小写，其他有意义的单词的首字母要大写，其余字母小写。

(2) 返回值类型可以是任意的Java类型，甚至可以是定义此方法的类。如果方

法没有返回值，则用void表示。

(3) 形式参数列表是可选的。如果方法没有形式参数，就用一对小括号“()”表

示。形式参数列表的形式如下： (类型 形参名，类型 形参名，……)

(4) throws异常列表规定了在方法执行中可能导致的异常。

3.创建一个有两个方法的类，其中第一个方法两次调用第二个方法，第一次不使

用this，第二个使用this。

class Rectangle //矩形类 {

int width; // 矩形的宽

int usethis(int width) //返回宽度的函数 {this. width= width; //指自己这个对象 return width; }

int unusethis(int width) { int w=width; return w; }

public static void main(String args[]) {

Rectangle r=new Rectangle(); //类对象的实例化 System.out.println(\ //输出语句 System.out.println(r.usethis(1)); System.out.println(r.unusethis(2)); 运行结果：

It is about the node of this. 1 2

4、创建一个类，该类还有int和char类型的成员变量且未被初始化，然后编程输

出这些成员变量的值，查看java是否执行了默认的初始化操作。 参考答案：

public class CuoShiHua {

int a; //整型变量 char b; //字符型变量

public void show() //用来输出未被初始化的变量的 {

System.out.println(a); System.out.println(b); }

public static void main(String[] args) {

CuoShiHua c = new CuoShiHua(); //声明类的对象并实例化 c.show(); //函数调用 } }

输出结果： 0

□ //小方格代表空格

5、创建一个类，该类含有的成员变量和成员方法，创建一个该类的对象，察看

当时图访问这些成员时，编译程序会给出那些信息（注意：在同一目录下的类都属于一个默认的包）。 class text1 {

static int a; //当被定义为static类型时，为类变量，可被对象

或类调用

int b; //对象变量，只能被对象调用 public void display(int a,int b) //成员方法 {

System.out.println(\ System.out.println(\ int b=\ }

public static void display(int b) {

System.out.println(\ }

public static void main(String args[]) {

text1 tt=new text1(); tt.display(5,6);

//text1.display(5,6)是错误的：对象变量或对象方法只能被对象tt调用 text1.display(0);

//当被定义为static类型时，为类方法，可被对象或类调用

tt.display(23); tt.a=9; text1.a=4; tt.b=3; } }

运行结果： static int a=5 int b=6

static display: int b=0 static display: int b=23

6、下面给出了一个矩形类Rectangle，其中含有多个构造方法。上机编译并运行

此程序，观察运行结果，体会其中不同构造方法的设计和使用。 import java.io.*;

class Rectangle //矩形类 {

private int width; //矩形的宽度 private int length; //矩形的长度

Rectangle() //矩形的不带参数的构造函数，缺省的给出长（30）和宽（20） {

length=30;width=20; }

Rectangle(int l,int w) //矩形的带参数的构造函数 {

length=l;width=w; }

Rectangle(Rectangle r) //此构造方法以另一个Rectangle作为参数 {

width=r.width(); //通过对象调用函数并附值给相应变量 length=r.length(); }

int width() //返回宽度 {

return width; }

int length() //返回长度 {

return length; } }

public class CRctngle {

public static void main (String args[ ]) {

Rectangle x1=new Rectangle(); //声明类的对象并实例化 Rectangle x2=new Rectangle(50,40); //声明类的对象并初始化 Rectangle x3=new Rectangle(x1); System.out.println(x1.length()); System.out.println(x1.width()); System.out.println(x2.length()); System.out.println(x2.width()); System.out.println(x3.length()); System.out.println(x3.width()); } }

运行结果：30 20 50 40 30 20

体会：此程序中共定义了3个构造方法：Rectangle()、Rectangle(int l,int w) 、

Rectangle(Rectangle r) ，其中Rectangle()是没有参数的，Rectangle(int l,int w)以常数作为参数，Rectangle(Rectangle r)是以对象最为参数。构造函数的调用实在用new运算符创建类对象是由系统自动完成的，构造函数的参数传递和形实结合也是由系统在调用的同时自动完成。 7、下面给出了一个计算阶乘的类Fact和使用该类计算阶乘的程序Check1。编译并运行该程序，观察运行结果，体会方法的参数的传递和返回值的用法。在调用时改变参数的个数和类型，看看编译时会得到什么信息。 class Fact {

float fact (int n) //定义计算n!的方法 { int i;

float x =1;

for(i=1;i

public class Check1 {

public static void main (String args[ ]) {

Fact x =new Fact( );

System.out.println(x.fact(10)); //计算10！ System.out.println(x.fact(15)); //计算15！ } }

运行结果： 1.0E9

2.91929271E16

8、编译并运行下面的程序，观察分析运行结果，体会程序中super和this的用法，进一步理解变量隐藏和方法重写的概念。 import java.io.*;

class SuperClss //定义父类 {

int x;

SuperClss( ) //父类的构造方法 { x=10; }

void doClss( ) {

System.out.println(\ } }

class SubClss extends SuperClss //定义子类 { int x;

SubClss( ) //子类的构造方法

{

super( ) ; x =100; }

void doClss( ) //重写父类的doClss方法 //调用父类的构造方法

{

System.out.println(\ }

void doDemo( ) { int x; x=1000;

super.doClss( ); doClss( ); System.out.println(\ System.out.println(\ System.out.println(\ } }

public class SuperDemo {

public static void main(String args[ ]) {

SubClss s = new SubClss();

//演示super和this的方法 //调用父类的doClss方法 //调用本类的doClss方法 //父类的x //本类的x //本方法的x //主方法

s.doDemo(); } }

运行结果： SuperClss.doClass() SubClss.doClss() super.x=10 this.x=100 x=1000

体会：此程序中定义了一个父类，子类SubClss继承了父类SuperClss,在主函数中定义SubClss类对象 s时（即执行语句：SubClss s = new SubClss();时 ），自动调用类SubClss的构造函数SubClss（），再此构造函数中先执行“super( ) ;”语句，这样就调用类SuperClss的构造方法SuperClss( )，因为super来指明超类中的方法。同样在子类方法doDemo( )中，执行语句“super.doClss( );”时，则调用父类的方法doClss( )。如不用super 来指定的话，，则调用的是子类的方法doClss( )，这里子类SubClss（）的成员方法doClss( )重写了父类SuperClss( )的成员方法doClss( )。

语句 “System.out.println(\”中super调用的是父类SuperClss的变量x，而语句 “System.out.println(\”中this调用的子类SubClss的变量x， 关键字this和super分别用来指明子类和父类中同名的成员变量。这里父类SuperClss的成员变量x、子类SubClss的成员变量x和类方法doDemo( )中使用的局部变量x三者同名，则要使用关键字this和super来指定所要使用的变量。如不用则输出的类方法的局部变量，如语句“System.out.println(\”输出的就是类方法doDemo()的局部变量。这里子类SubClss（）的成员变量x隐藏了父类SuperClss( )的成员变量x。

9、编译并运行下面的程序，分析运行结果，体会其中方法重载的用法，进一步理解方法重载的概念。

class Father //本类中的speak方法重载了两次 {

void speak( ) //无参数的speak方法 {

System.out.println(″I am Father! ″);

}

void speak(String s) //有参数的speak方法 {

System.out.println(″I like″+″″+s+″. ″); }

}

public class OverLoadingDemo {

public static void main (String args[ ]) {

Father x = new Father( );

x.speak(); //调用无参的speak方法 x.speak(″music″) //调用有参的speak方法 } }

运行结果： I am Father! I like music.

第五章 习题及思考题

1、 什么是继承?什么是父类?什么是子类?继承的特性可给面向对象编程带来 什么好处?什么是单重继承?什么是多重继承?

解：继承是面向对象程序设计中两个类之间的一种关系。当一个类获取另一个类中 所有非私有的数据和操作的定义作为它自己的部分或全部成分时，就称这两个类之间具 有继承关系。被继承的类称为父类或超类，继承了父类或超类的所有数据和操作的类称 为子类。

面向对象程序设计中的继承，可使得程序结构更加清晰，降低了编码和维护的工作量。 如果一个类只能有一个父类，则这种继承关系称为单重继承；如果一个类可以有多个 父类，则这种继承关系称为多重继承。

2、 “子类的域和方法的数目一定大于等于父类的域和方法的数目”，这种说法是否 正确?为什么?

解：这种说法是错误的，因为子类不一定能继承父类的所有域和方法，它只能继承所 有非私有的域和方法。如果子类在继承之外自己定义的域和方法数目小于父类中私有成 员的数目，则子类的域和方法的数目小于父类的域和方法的数目。

3、什么是方法的覆盖?方法的覆盖与域的隐藏有何不同?与方法的重载有何不同?

解；子类重新定义父类中已经存在的方法，称为方法的覆盖。注意：方法覆盖与域的 隐藏不同。子类重新定义父类已有的域，并不能完全取代它从父类那里继承的同名的域，

这个域仍然占用子类的内存空间，在某些情况下会被使用；而当子类重新定义父类的方法 时，从父类那里继承来的方法将被新方法完全取代，不再在子类的内存空间中占一席

之地。 与方法的覆盖不同，重载不是子类对父类同名方法的重新定义，而是在一个类中定义了同名的不同方法。

4、 什么是多态?面向对象程序设计为什么要引人多态的特性?使用多态有什么优点?

解：一个类中存在多个同名的方法，称为多态。把抽象功能和目的相同，而具体实现 因不同情况而异的方法命名为同名方法，符合面向对象程序设计中抽象、提升概念，封装、 隐藏细节的特点，从而提高了程序的简洁性和可读性，降低了类和程序模块直接的相互耦 合和依赖。

5、 父类对象与子类对象相互转化的条件是什么?如何实现它们的相互转化?

解：一个子类对象也可以被合法地视为一个父类的对象，即一个父类对象的引用，其 指向的内存单元可能实际上是一个子类的对象。在这种情况下，可以使用强制类型转换， 将父类对象的引用转换成实际的子类对象的引用

6、什么是包?它的作用是什么?

解：包是一种松散的类的集合。包的作用主要是把需要协同工作的不同的类组织在 一起，使得程序功能清楚、结构分明。

7、 CLASSPATH是有关什么的环境变量?它如何影响程序的运行?如何设置 和修改这个环境变量?

解：CLASSPATH是指定缺省的包文件(字节码文件)路径的环境变量。如果

CLASSPATH设置得不正确，则程序编译、运行时可能找不到所需的类的字节码文件，从 而使程序无法正常运行。

使用如下命令设置或修改CLASSPATH： SET classpath=,;d:\\jdk1.5.0\\lib\\ext

8、 一个类如何实现接口?实现某接口的类是否一定要重载该接口中的所有抽象 方法?

解：使用关键字implements可以定义类实现某接口。实现某接口的类如果不是抽 象类，则需要通过重载来实现该接口中的所有抽象方法；如果这个类是抽象类，则它可以 不必实现该接口中的所有抽象方法。

9、 为某研究所编写一个通用程序，用来计算每一种交通工具运行1000公里所需的时间，已知每种交通工具的参数都是3个整数A、B、C的表达式。现有两种工具：Car007 和Plane，其中Car007 的速度运算公式为：A*B/C，Plane 的速度运算公式为：A+B+C。需要编写三类：ComputeTime.java,Plane.java,Car007.java和接口Common.java，要求在未来如果增加第3种交通工具的时候，不必修改以前的任何程序，只需要编写新的交通工具的程序。其运行过程如下，从命令行输入ComputeTime的四个参数，第一个是交通工具的类型，第二、三、四个参数分别时整数A、B、C，举例如下：

计算Plane的时间：\ 计算Car007的时间：\ 如果第3种交通工具为Ship,则只需要编写Ship.java，运行时输入：\ComputeTime Ship 22 33 44\

提示：充分利用接口的概念，接口对象充当参数。

实例化一个对象的另外一种办法：Class.forName(str).newInstance（）；例如需要实

例化一个Plane对象的话，则只要调用Class.forName(\便可。 解：ComputerTime.java 源程序： import pkg1.pkg2.*; import java.lang.*;

public class ComputerTime

{ public static void main(String args[])

{ System.out.println(\交通工具: \ System.out.println(\参数A: \ System.out.println(\参数B: \ System.out.println(\参数C: \ double A=Double.parseDouble(args[1]); double B=Double.parseDouble(args[2]); double C=Double.parseDouble(args[3]); double v,t; try { Common d=(Common) Class.forName(\ v=d.runtimer(A,B,C); t=1000/v;

System.out.println(\平均速度: \ System.out.println(\运行时间：\小时\ }

catch(Exception e)

{ System.out.println(\ } } }

包pkg1中Car007.java的源程序： package pkg1;

import pkg1.pkg2.*;

public class Car007 implements Common

{ public double runtimer(double A,double B,double C) { System.out.println(\ return A*B/C; } }

包pkg1中Plane.java的源程序： package pkg1;

import pkg1.pkg2.*;

public class Plane implements Common {

public double runtimer(double A,double B,double C) {

return A+B+C; } }

包pkg2中Common.java的源程序： package pkg1.pkg2;

public interface Common

{ double runtimer(double A,double B,double C); }

10、编写求解几何图形（如直线、三角形，矩型，圆，多边型）的周长，面积的应用程序，要求用到继承和接口等技术。

解：// Solution of drawings as triangle,rectangle,circle

import java.io.*; // interface

interface getProperty {

double Pi=3.1415926; double getArea(); double getCircum(); String getName(); } //

class mpoint {

static int i=0; double x,y;

String strmpoint;

mpoint(double a,double b) {

this.x=a; this.y=b; }

double getX(){ return x; }

double getY() {

return y; }

String getString()

{

i+=1;

strmpoint=\ return strmpoint; } }

//disp class class disp { double area; double circum;

String drawingName;

disp(double a, double b, String ss){ this.area=a; this.circum=b;

this.drawingName=ss; }

public void display(){

System.out.println(\ System.out.println(\ } }

// class triangle

class triangle implements getProperty { mpoint p1,p2,p3; double s1,s2,s3;

String drawingName=\

triangle(mpoint p1,mpoint p2,mpoint p3){ this.p1=p1; this.p2=p2; this.p3=p3;

this.s1=Math.sqrt( (p1.x-p2.x)*(p1.x-p2.x)+ (p1.y-p2.y)*(p1.y-p2.y) ); this.s2=Math.sqrt( (p3.x-p2.x)*(p3.x-p2.x)+ (p3.y-p2.y)*(p3.y-p2.y) ); this.s3=Math.sqrt( (p1.x-p3.x)*(p1.x-p3.x)+ (p1.y-p3.y)*(p1.y-p3.y) ); }

public double getArea(){ double ss,ssa;

ss=(s1+s2+s3)*Pi/2.0/Pi;

ssa=Math.sqrt( ss*(ss-s1)*(ss-s2)*(ss-s3) ); return ssa; }

public double getCircum(){

return s1+s2+s3; }

public String getName(){ return drawingName; }

public boolean tline(){ return true; } } //

// circle class

class circle implements getProperty { mpoint p1; double radius;

String drawingName=\ circle(mpoint p1,double radius){ this.p1=p1;

this.radius=radius; }

public double getArea(){ double ssa;

ssa=Math.PI*radius*radius; return ssa; }

public double getCircum(){ return Math.PI*2.0*radius; }

public String getName(){ return drawingName; }

public boolean tcircle(){ return true; } }

// class rectangle

class rectangle implements getProperty { mpoint p1,p2; double s1,s2;

String drawingName=\ rectangle(mpoint p1,mpoint p2){ this.p1=p1; this.p2=p2;

this.s1=Math.sqrt( (p1.x-p2.x)*(p1.x-p2.x) );

this.s2=Math.sqrt( (p1.y-p2.y)*(p1.y-p2.y) ); }

public double getArea(){ return s1*s2; }

public double getCircum(){ return s1+s2+s1+s2; }

public String getName(){ return drawingName; }

public boolean rline(){ return true; } }

// mainclass

class drawing extends disp {

drawing(double a, double b, String ss){ super(a,b,ss); }

public static void main(String args[])throws IOException {

BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in));

String strxx; for(;true;) {

System.out.print(\、Rectangle or Circle:\ strxx=keyin.readLine();

if (strxx.length()==0) continue;

char charxx;

charxx=strxx.toUpperCase().charAt(0); switch( charxx ) {

case 'T':

// triangle start // 3point get

System.out.println(\ mpoint p1=new mpoint(aVar(keyin),aVar(keyin));

System.out.println(\ mpoint p2=new mpoint(aVar(keyin),aVar(keyin));

System.out.println(\

mpoint p3=new mpoint(aVar(keyin),aVar(keyin)); // t1

triangle t1=new triangle(p1,p2,p3); // disp

disp tdisp =new disp(t1.getArea(),t1.getCircum(),t1.getName()); tdisp.display();

// mpoint p1=p2=p3=null; // disp tdisp=null; // triangle end break;

// -------------------------------------------------------------------

case 'C': // circle start // 1point get

System.out.println(\ mpoint p4=new mpoint(aVar(keyin),aVar(keyin));

System.out.println(\ double radius=aVar(keyin); // t2

circle t2=new circle(p4,radius); // disp

disp cdisp =new disp(t2.getArea(),t2.getCircum(),t2.getName()); cdisp.display(); // circle end break;

// --------------------------------------------------------------------

case 'R':

// rectangle start // 2point get

System.out.println(\ mpoint p6=new mpoint(aVar(keyin),aVar(keyin));

System.out.println(\ mpoint p7=new mpoint(aVar(keyin),aVar(keyin)); // t3

rectangle t3=new rectangle(p6,p7); // disp

disp rdisp =new disp(t3.getArea(),t3.getCircum(),t3.getName()); rdisp.display(); // circle end break;

// ----------------------------------------------------------------------

default: System.out.println(\ } // switch

} //endoffor

} //main method

static double aVar(BufferedReader keyin) throws IOException { // get a double var String xx;

xx=keyin.readLine();

return Double.parseDouble(xx); } }

第六章 习题及思考题

a) 找出以下有问题的代码

pulic int searchAccount(int[25] number){ number =new int[15];

for(int i=0;i

number[i]=number[i-1]+number[i+1]; return number; } 解答：

①数组的参数说明中不能每含有长度(25)的信息。

②for循环中，当i=0时,number[i-1]=number[-1]；这表示已经越界，并产生数组下标越界例外错误。 ’

③return返回语句不是int类型，必须是int[]类型，因为number是数组。

2、将一个字符串中的小写字母变成大写字母,并将大写字母变成小写字母. 解：import java.util.*;

public class Example6_8{

public static void main(String args[]){ String s=new String(\System.out.println(s); char a[]=s.toCharArray(); for(int i=0;i

{ if(Character.isLowerCase(a[i])) { a[i]=Character.toUpperCase(a[i]); }

else if(Character.isUpperCase(a[i])) { a[i]=Character.toLowerCase(a[i]);

} }

s=new String(a);

System.out.println(s); } }

3、求若干个数的平均数,若干个数从键盘输入.

public class Example5_5

{ public static void main(String args[]) { double n,sum=0.0 ;

for(int i=0;i

{ sum=sum+Double.valueOf(args[i]).doubleValue(); }

n=sum/args.length;

System.out.println(\平均数:\} }

应用程序中的main 方法中的参数args 能接受你从键盘键入的字符串.首先编译上述源程序

D:\\>javac Example5_5.java

编译通过后,你要使用解释器java.exe来执行你的字节码文件 D:\\>java Example5_5 \回车)

这时,程序中的args[0],arg[1],arg[2]分别得到字符串\和\在源程序中我们再将这些字符串转化为数值进行运算,得到所需的结果.

4、将一个字符串数组按字典序重新排列. class Example5_4{

public static void main(String args[]){

String a[]={\for(int i=0;i

for(int i=0;i

}

5、编写应用程序,分析字符串,分别输出字符串的单词,并统计出单词个数.

import java.util.*; public class Example5_7{

public static void main(String args[]){ String s=\

StringTokenizer fenxi=new StringTokenizer(s,\ //空格和逗号做分 int number=fenxi.countTokens(); while(fenxi.hasMoreTokens()) { String str=fenxi.nextToken(); System.out.println(str);

System.out.println(\还剩\个单词\}

System.out.println(\共有单词\个\} }

6、使用java.lang 包中System 类的静态方法arraycopy 可以实现数组的快速拷贝

class ArrayCopy{

public static void main(String args[]){

char a1[]={'a','b','c','d','e','f'},b1[]={'1','2','3','4','5','6'}; System.arraycopy(a1,0,b1,1,a1.length-1); System.out.println(new String(a1)); System.out.println(new String(b1));

byte a2[]={97,98,99,100,101,102},b2[]={65,67,68, 69, 70, 71}; System.arraycopy(b2,0,a2,3,b2.length-3); System.out.println(new String(a2)); System.out.println(new String(b2)); } }

7、运行下面程序，给出结果

public class Example4{

public static void main(String args[]){ byte d[]=\你我他\

System.out.println(\数组d的长度是(一个汉字占两个字节):\String s=new String(d,0,2); System.out.println(s); } }

解：上述程序的输出结果

数组d的长度是(一个汉字占两个字节) 6 你

第七章 习题及思考题

1、 编写判断某年是否是闰年的Java程序。

解: public class Date1 {

int year,month,day;

void setdate(int y,int m,int d) //成员方法，设置日期值

{ //公有的，无返回值，有三个参数 year = y; month = m; day = d; }

boolean isleapyear() //判断年份是否为闰年 { //布尔型返回值，无参数 return (year@0==0) | (year0!=0) & (year%4==0); }

void print() //输出日期值，无返回值,无参数 {

System.out.println(\ }

public static void main(String args[]) {

Date1 a = new Date1() ; //创建对象 a.setdate(2002,4,18); //调用类方法 a.print();

System.out.println(a.year+\ } }

2、 已知f(n)公式如下：

f(1)=f(2)=1 当n=1，2 f(n)=f(n-1)+f(n-2) 当n>=3

计算f(28)的结果，并测试计算该公式所花的时间数。（提示：可以用System类的静态方法public long currentTimeMillis()获取系统当前时间，也可以根据currentTimeMillis()方法得到的数字,用Date 的构造方法） 解：

import java.util.Date; class Example6_2

{ public static void main(String args[]) { long time1=System.currentTimeMillis(); Date date=new Date(time1); System.out.println(date);

String s=String.valueOf(time1);

int length=s.length(); s=s.substring(length-8); System.out.println(s); long result=f(28);

System.out.println(\

long time2=System.currentTimeMillis(); //计算f(28)之后的时间. s=String.valueOf(time2);

length=s.length(); s=s.substring(length-8); System.out.println(s);

System.out.println(\用时\毫秒\}

public static long f(long n) { long c=0;

if(n==1||n==2) c=1;

else if(n>=3) c=f(n-1)+f(n-2); return c; } }

3、 利用Vector类，实现一个先进先出队列。 解： import java.util.*;

import java.io.*; public class Queue {

public static void main(String args[]) { Vector theVector = new Vector(); //创建一空向量实例 theVector

byte bytebuffer[] = new byte[10]; try{

System.out.print(\ //确定队长size，即向量实例 theVector的大小 System.in.read(bytebuffer);

String c = new String(bytebuffer); int size = Integer.parseInt(c.trim() );

System.out.println(\ //往向量中插入对象，即入队

for(int i = 0; i < size; i++) {

System.in.read(bytebuffer);

String s = new String(bytebuffer); s.trim();

theVector.addElement(s); //把给定对象增加到向量队尾 }

for(int i = 0; i < size; i++) {

System.out.println(\Number: \i +\OutQueue Element: theVector.firstElement());

//输出队列首元素及其出对序列号

theVector.removeElementAt(0); //删除给定下标的向量元素，即出队 }

\

} catch(Exception e){} } }

运行结果：

D:\\pro>java Queue

please input the length of the Queue:3 please input the element of the Queue: 563 ertet 23.34

OutQueue Number: 0 OutQueue Element: 563 OutQueue Number: 1 OutQueue Element: ertet OutQueue Number: 2 OutQueue Element: 23.34

4、将从小到大的素数30个放入数组中。 解：public class Prime_array {

public static void main(String args[]) {

final int MAX=100,SIZE=30; int prime[] = new int [SIZE]; int i,j,k,n;

prime[0]=2; //已知的最小素数

n=1; //素数个数,即数组的实际长度(元素个数) i=1; //下一个素数应存放的数组下标位置

k=3; //从最小奇数开始测试,所有偶数不需测试 do {

j=0;

while ((j

prime[i]=k; i++; n++; }

k=k+2; //测试下一个奇数是否是素数 } while(k

System.out.println(\ for (i=0;i

System.out.print(\

if ((i+1)==0) System.out.println();

}

System.out.println(\ } }

5、编写生成100个1-6之间的随机数，统计1—6每个出现的概率。 解：public class ch6_e6_4 {

public static void main(String args[]) {

final int NUMBER = 100; int count = 10; int randomNum = 0;

int probability[] = new int[6];

for(int i=0; i<6; i++) {

probability[i] = 0; }

for(int i=0; i

randomNum = (int)(Math.random()*6) + 1; probability[randomNum-1]++;

System.out.print(randomNum + \ if(i%count == 9)

System.out.println(); }

for(int i=0; i<6; i++) {

System.out.println(\ + probability[i]); } } }

6、 在所有的Java系统类中，Object类有什么特殊之处?它在什么情况下使用?

解：Object类是所有Java类、系统类或用户自定义类的直接或间接父类。因为任何 一个Java对象都可以同时看作是Object类的对象，所以Object可以使用在通用或泛指 的情况下，例如作为某些形式参数的类型。

7、 试列举你使用过的数据类型类，数据类型类与基本数据类型有什么关系?

解：常用的数据类型类有Boolean，Byte，Character，Double，Float，Integer，Long， Short等。

数据类型类基于基本数据类型，其中封装了一个基本数据类型的域及与其相关的 操作。

8 Math类用来实现什么功能?设x，y是整型变量，d是双精度型变量，试书写表 达式完成下面的操作： (1)求x的y次方。 (2)求x和y的最小值。 (3)求d取整后的结果。 (4)求d四舍五人后的结果。 (5)求atan(d)的数值。

解；Math类中包含了若干常用的数学运算。 (1)Math．pow(x，y) (2)Math．min(x，y) (3)Math．floor(d) (4)Math．round(d) (5)Math．atan(d)

9、向量与数组有何不同?它们分别适合于什么场合?

解：向量是类似于数组的顺序存储的数据结构，不同之处是向量中的每个元素都是 对象，向量中还封装了一些常用的数据处理功能，因此向量是允许不同类型元素共存的变

长数组。

下面的情况下适合使用向量：

(1)需要处理的对象数目不定：序列中的元素都是对象，或可以表示为对象。 (2)需要将不同类的对象组合成一个数据序列。 (3)需要做频繁的对象序列中元素的插人和删除。 (4)经常需要定位序列中的对象或其他的查找操作。 (5)需要在不同的类之间传递大量的数据。

(6)Vector类的方法相对于数组要多一些，但是使用这个类也有一定的局限性，例如

其中的对象不能是简单数据类型等。 一般在下面的情况下，使用数组比较合适 （1） 序列中的元素是简单数据类型的数据

（2） 序列中的元素数目相对固定，插入、删除和查找 操作较少。 10、什么是排序?你了解几种排序算法?它们各自有什么优缺点?分别适合在什么情况下使用? 解：排序是把一个数据序列中的各个数据元素，根据其中所包含的某个关键值进行 从大到小或从小到大排列的过程。排序的目的大都是为了方便对数据序列中的元素进行 查找。 常见的排序算法有：冒泡排序、选择排序、插入排序、桶排序和快速排序等。

其中冒泡排序的算法和代码比较简单，适合在待排序的数据元素数目不太多的情况，

32

其算法复杂度为n。选择排序和插入排序的算法代价为n，运算量大大减少，其中选择 排序所需的操作比较多，移动操作少，而插入排序的比较操作少，移动操作多，综合起来二 者大体不相上下。桶排序的算法复杂性为n，运算量最小，但是代价是占用较多的内存空间(10n)。快速排序的算法复杂性也是n。需要注意的是，这里算法复杂性指出的运算 量都是在最坏情况下的运算量，实际使用时可以根据需要排序的数据元素自身的特点，如

是否已经部分有序，来选择相应的算法。

第八章 习题及思考题

1. 什么是异常？简述Java的异常处理机制。

答：异常是当程序运行的时候，由于各种不可避免的原因而产生的错误。例如除数为零、文件找不到而无法读写、网点连接不上等等。

Java程序把运行中各种可能出现的错误都看作异常，Java提供的异常情况处理机制叫异常处理。Java 提供了两种不同的异常抛出机制：throws抛出异常和 throw 抛出异常。throws抛出异常又叫间接抛出异常，throw抛出异常又叫直接抛出异常。throws抛出异常和方法说明联系在一起，是针对以下情况：调用的方法抛出了异常、检测到了错误并使用throw语句抛出异常、程序代码有错误从而异常。方法中出现的异常由catch语句捕获，进行处理。

2. 系统定义的异常与用户自定义的异常有何不同？如何使用这两类异常？ 答：系统定义的运行异常通常对应着系统运行错误。由于这种错误可能导致操作系统错误甚至是整个系统的瘫痪，所以需要定义异常来特别处理。而用户自定义异常用来处理程序中可能产生的逻辑错误，使得这种错误能够被系统及是识别并处理，而不至扩散产生更大影响，从而使用户程序更为强健，有更好的容错能力，并使整个系统更加安全稳定。 使用：

（1）声明一个新的异常类，是之以Exception类或其他莫个已经存在的系统异常类或用户异常类为父类。

（2）为新的异常类定义属性和方法，或重载父类的属性和方法，使这些属性和方法能过体现该类所对应的错误的信息。

只有定义可以场类。系统才能够识别特定的运行错误，才能够及时的控制和处理运行错误，所以定义足够多的异常类是构件一个稳定完善的应用系统的重要基础之一。

3．输入并运行下面的程序： class testTry {

public static void main(String args[ ]) {

Proc(0); Proc(100); Proc(1); }

static void Proc(int num) { try {

System.out.println(\异常处理测试 ***\ System.out.println(\ int sum = 100/num; int array[ ]={0,1,2}; array[num]=sum; }

catch( ArithmeticException e ) {

System.out.println(\被零除：\ }

catch( ArrayIndexOutOfBoundsException e ) {

System.out.println(\数组越界：\ }

finally {

System.out.println(\ } } }

问题:在java的异常处理机制中,try程序块、catch程序块和finally程序块各起到什么作用？ 运行结果：

***异常处理测试 *** num=0

被零除：java.lang.ArithmeticException: / by zero End!

***异常处理测试 *** num=100

数组越界：java.lang.ArrayIndexOutOfBoundsException: 100 End!

***异常处理测试 *** num=1 End!

问题答案：

Try程序块作用： 说明抛出异常的部位，该部位含有抛出异常的语句。

Catch程序块作用：接抛出的异常类进行捕获，并进行处理。当catch前面的try 块中发生了一个异常，try-catch语句就会自动在try块后面的各个catch块中，找出与该异常类相匹配的参数。当参数符合以下3个条件之一时，就认为这个参数与产生的异常相匹配： 参数与产生的异常属于一个类； 参数是产生的异常的父类；

参数是一个接口时，产生的异常实现了这一接口。

当产生的异常找到了第一个与之相匹配的参数时，就执行包含这一参数的catch语句中的java代码。

Finally程序快作用：finally语句可以说是为异常处理事件提供的一个清理机制，一般是用来关闭文件或释放其他的系统资源。作为try-catch-finally结构的一部分，可以没有 finally语句，如果存在finally语句，不论try块中是否发生了异常，是否执行过catch 语句，都要执行finally语句。

4．编写从键盘读入10个字符放入一个字符数组，并在屏幕上显示它们的程序。请处理数组

越界异常.

import java.io.*; class ReadChar {

public static void main(String args[])throws IOException {

char buf[]=new char[10]; //10字节的数组用于存字符串，buf为局部变量, System.out.println(\ char ch;

for(int i=0;i<10;i++)

buf[i]=(char)System.in.read(); //从键盘读一个数字串保存于buf中，它引发异常

for(int j=0;j<10;j++)

System.out.print(buf[j]+\ } }

运行结果：

D:\\java\\pro>java ReadChar Input 10 char! uiwryiufys

u i w r y i u f y s

第九章 习题及思考题

1、编一个应用程序，按行顺序地读取一个可读文件的内容。 解：import java.io.*; public class ReadFile

{ public static void main(String args[]) { String s;

FileInputStream is; InputStreamReader ir; BufferedReader in; try

{ is=new FileInputStream(\ ir=new InputStreamReader(is); in=new BufferedReader(ir); while((s=in.readLine())!=null) System.out.println(\ }

catch(FileNotFoundException e)

{ System.out.println(\ System.exit(-2); }

catch(IOException e)

{ System.out.println(\ System.exit(-3); } } }

2、把Hashtable存放的信息输出到磁盘文件中，并再从中读进Hashtable. import java.io.*;

import java.util.Hashtable;

public class ObjectIOClass extends implements Serializable{ public static void main(String args[]) throws Exception {

Hashtable ht=new Hashtable(); //建立Hashtable 的对象实例 DataInputStream dis=new DataInputStream(System.in); //建立DataInputStream对象，并且与//标准输入对象连接。

String st_no=dis.readLine(); //从标准输入读一行存入st_no String st_rec=dis.readLine(); //从标准输入读一行存入st_rec

ht.put(st_no,st_rec); //st_no作关键字，st_rec为Hashtable保存的对象,存入ht

System.out.println(ht);

String st_no1=dis.readLine(); //从标准输入读一行存入st_no1

if (ht.containsKey(st_no1)) //如Hashtable对象中有st_no1，打印对应的对象 System.out.println(ht.get(s3)); else System.out.println(\

ObjectReadWrite my_object=new ObjectReadWrite (); //建立文件对象 my_object.write(ht); //如ht对象输出到输出源 my_object.read(); //从输入源读入对象 }}

public class ObjectReadWrite {

static File object_file=new File(\public static void write(Hashtable ht ) { try{

//建立FileOutputStream对象，并且与文件对象object_file 连接 FileOutputStream fos=new FileOutputStream(object_file); // 建立ObjectOutputStream对象，并且与文件对象fos连接 ObjectOutputStream oos=new ObjectOutputStream ( fos);

oos.writeObject(ht); //Hashtable对象内容写入输出文件中 //o1.flush(); oos.close();

} catch(Exception e){}; }

public static void read(){ //从对象输入文件中读对象 try{

//建立ObjectOutputStream对象，并且与文件对象object_file 连接。

ObjectInputStream ois=new ObjectInputStream( new FileInputStream(object_file )); Hashtable ht1=(Hashtable)ois.readObject(); //从输入源读入对象 System.out.println(ht1); //标准输出ht1 }

catch(Exception e){ e.printStackTrace(); } } }

3、利用StringBuffer类编写从键盘读入字符串、整数、实型数，并在屏幕上输出。 源程序：

import java.io.*;

public class StringBufferToString {

public static void main(String[] args) throws IOException {

char ch;

StringBuffer strb = new StringBuffer(); //创建一个空的StringBuffer类 System.out.println(\Enter the char ,int number or float number:\ while((ch = (char)System.in.read() )! = '\\n') {

strb.append(ch); //把字符连接到当前串尾 }

String str = strb.toString( ); //把StringBuffer类转换为String类 System.out.println(\ System.out.println(str); } }

4、什么叫流？简述流的分类？

“流”可以被理解为一条“管道”。这条“管道”有两个端口：一端与数据源（当输入数据时）或数据宿（当输出数据时）相连，另一端与程序相连。在与数据源或是数据宿相连的端口，“管道”在读/写数据时能够应付数据源和数据宿的多样性，消化掉因数据源和数据宿的多样性带来的数据读/写的复杂性；而在与程序相连的端口，“管道”提供了输入/输出的统一界面。

根据流中的数据传输的方向，流可分为输入流和输出流；根据“管道”里流动的数据的类型，流可分为字符流和字节流；根据流的建立方式和工作原理，流可分为节点流与过滤流。

5、编写一个测试文件一般属性（如显示文件的路径、绝对路径、显示文件是否可写、显示文件是否可读、显示文件的大小等属性）的程序。 import java.io.*;

public class FileInfo

{

public static void main(String[] args) {

System.out.println(\ char c;

StringBuffer buf = new StringBuffer( ) ; try {

while( (c = (char)System.in.read() ) != '\\n') buf.append(c);

//将输入的字符加到buf中，直到遇见回车符 } catch(java.io.IOException e) {

System.out.println(\ }

File file = new File(buf.toString( ).trim( ) ); //创建File类的file对象

if ( file.exists( ) )

//如果文件在当前目录存在 {

System.out.println(\ //显示文件的文件名

System.out.println(\ //显示文件的路径

System.out.println(\ //显示文件的绝对路径

System.out.println(\ //显示文件是否可写

System.out.println(\ // 显示文件是否可读

System.out.println(\ //显示文件的大小 }

else //如果文件不在当前目录

System.out.println(\ //显示文件没有找到的提示消息 } }

6、利用RandomAccessFile类编写应用程序，要求输入10组数据到文件中，每组数据为1个整形数和一个双精度数，然后随机修改文件的某组数，并显示修改的结果。 import java.io.*;

public class testRandom2{

public static void main(String args[]){ try{

RandomAccessFile rf=new RandomAccessFile(\for(int i = 0; i < 10; i++){ rf.writeInt(i);

rf.writeDouble(i*1.414); }

rf.close();

rf = new RandomAccessFile(\rf.seek(5*(4+8)); rf.writeInt(47);

rf.writeDouble(47.0001); rf.close();

rf = new RandomAccessFile(\for(int i = 0; i < 10; i++){ ;

System.out.println(\}

rf.close();

}catch(IOException e){

System.out.println(e.toString()); } } } 7、将如下三组不同类型的数据利用DataInputStream和DataOutputStream写入文件，然后从文件中读出。 三组数据如下

{ 19.99, 9.99, 15.99,3.99, 4.99 }; { 12, 8, 13, 29, 50 };

{ \

解：import Java.io.*; public class DataIOTest {

public static void main(String[] args) throws IOException {

//创建数据输出流

DataOutputStream out = new DataOutputStream(new FileOutputStream(\ //初始化输出数据

double[] prices = { 19.99, 9.99, 15.99, 3.99, 4.99 }; int[] units = { 12, 8, 13, 29, 50 }; String[] descs = {

\

\

\ \

\};

//数据输出

for (int i = 0; i < prices.length; i ++) {

out.writeDouble(prices[i]); out.writeChar('\\t'); out.writeInt(units[i]); out.writeChar('\\t');

out.writeChars(descs[i]); out.writeChar('\\n'); }

//关闭数据输出流 out.close(); //创建数据输入流

DataInputStream in = new DataInputStream( new FileInputStream(\

double price; int unit; String desc;

double total = 0.0; try {

//利用数据输入流读文件内容 while (true) {

price = in.readDouble();

in.readChar(); // throws out the tab unit = in.readInt();

in.readChar(); // throws out the tab desc = in.readLine();

System.out.println(\ unit + \ desc + \ total = total + unit * price; } }

//捕获异常 catch (EOFException e)

{

e.printStackTrace(); }

System.out.println(\ //关闭数据输入流 in.close(); } }

8、利用BufferedReader和BufferedWriter在文件中实现输入输出字符串。 import java.io.*;

public class ko24_6 {

public static void main(String args[]) throws IOException {

String line;

String str=\

BufferedWriter kow=new BufferedWriter(new FileWriter(\ kow.write(str,0,str.length()); kow.flush(); BufferedReader kor=new BufferedReader(new FileReader(\ line=kor.readLine(); System.out.println(line); } }

9、什么是过滤流，并举例

解：过滤流在读/写数据的同时可以对数据进行处理，它提供了同步机制，使得某一时刻只有一个线程可以访问一个I/O流，以防止多个线程同时对一个I/O流进行操作所带来的意想不到的结果。类FilterInputStream和FilterOutputStream分别作为所有过滤输入流和输出流的父类。

为了使用一个过滤流，必须首先把过滤流连接到某个输入/出流上，通常通过在构造方法的参数中指定所要连接的输入/出流来实现。例如：

FilterInputStream( InputStream in ); FilterOutputStream( OutputStream out ); 下面的类均是过滤流的例子

BufferedInputStream和BufferedOutputStream 缓冲流，用于提高输入/输出处理的效率。 DataInputStream 和 DataOutputStream 不仅能读/写数据流，而且能读/写各种的java语言的基本类型，如：boolean，int，float等。

LineNumberInputStream

除了提供对输入处理的支持外，LineNumberInputStream可以记录当前的行号。

PushbackInputStream

提供了一个方法可以把刚读过的字节退回到输入流中，以便重新再读一遍。 PrintStream

打印流的作用是把Java语言的内构类型以其字符表示形式送到相应的输出流。

10、什么是串行化，并举例

解：对象的寿命通常随着生成该对象的程序的终止而终止。有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复。我们把对象的这种能记录自己的状态以便将来再生的能力，叫做对象的持续性(persistence)。对象通过写出描述自己状态的数值来记录自己，这个过程叫对象的串行化(Serialization)。

串行化的目的是为java的运行环境提供一组特性，其主要任务是写出对象实例变量的数值。

首先定义一个可串行化对象

public class Student implements Serializable{ int id; //学号

String name; //姓名 int age; //年龄

String department //系别

public Student(int id,String name,int age,String department){ this.id = id; this.name = name; this.age = age;

this.department = department; } }

其次是构造对象的输入/输出流

java.io包中，提供了ObjectInputStream和ObjectOutputStream将数据流功能扩展至可读写对象。在ObjectInputStream中用readObject()方法可以直接读取一个对象，ObjectOutputStream中用writeObject()方法可以直接将对象保存到输出流中。 Student stu=new Student(981036,\ FileOutputStream fo=new FileOutputStream(\ //保存对象的状态

ObjectOutputStream so=new ObjectOutputStream(fo); try{

so.writeObject(stu); so.close();

}catch(IOException e )

{System.out.println(e);}

FileInputStream fi=new FileInputStream(\ ObjectInputStream si=new ObjectInputStream(fi); //恢复对象的状态 try{

stu=(Student)si.readObject(); si.close();

}catch(IOException e ) {System.out.println(e);

}

第十章 习题及思考题

1．什么是线程？它产生的背景是什么？线程有几种状态？说明状态变化调用的方法。 答：线程是一个进程在执行过程中产生的多条执行线索。每个线程有它产生、存在和消亡的过程，是动态的。线程由线程内核对象和线程堆栈两部分组成，相对于组成进程的内核对象及虚拟地址空间，线程使用的系统资源比进程少得多。

它产生的背景是：操作系统按照一定的策略(优先级、循环等)调度各个进程执行，以最大限度地利用计算机的各种资源。一个进程运行期间，拥有的主要资源包括地址空间(存放text,data,stack)、打开文件表、资源控制信息、核心栈。除了text可被其他进程共享外，上述资源都属进程私有。因此CPU从运行一个进程转换到运行另一个进程时，为进程保存、恢复的开销很大，并发效率低。如果把进程所占私有资源与进程中的运行代码相分离，在一个地址空间中便可运行多个代码段，由此产生线程概念。 线程的状态有以下四种：（1）创建状态(New Thread) （2）运行状态(Runnable) （3）不可运行状态(Not Runnable) （4）死亡状态(Dead)

对于上面4种状态，各有特定的使线程返回可运行状态的方法与之对应，如下所述：

(1)如果线程处于睡眠状态中，sleep()方法中的参数为休息时间，当这个时间过去后，线程即为可运行的；

(2)如果一个线程被挂起，需调用resume()方法才能返回；

(3)如果线程在等待条件变量，那么要停止等待的话，需要该条件变量的线程对象调用notifyAll()方法；

(4)如果在I/O流中发生线程阻塞，则特定的I/O完成可结束这种不可运行状态。 需要注意的是每种方法仅仅对相应的情况才有作用，例如当一个线程睡眠并且睡眠时间还没有结束时，调用resume()方法是无效的。

2、 实现两个定时线程，一个线程每隔1秒显示一次，一个线程每隔3秒显示一次。 答：源程序：

import java.io.*;

public class Time {

static Lefthand left; //声明静态的类的对象 static Righthand right;

public static void main(String args[]) {

left=new Lefthand() ; //创建两个线程。 right=new Righthand();

left.start(); //线程开始运行后，Lefthand类中的run方法将被执行。

right.start(); } }

class Lefthand extends Thread //lefthand类继承Thread类 {

public void run() {

for(;;) {

System.out.println(\每1秒显示一次！\Try {

sleep(1000); //使当前活动线程睡眠1秒 }

catch(InterruptedException e){} //捕捉异常 } } }

class Righthand extends Thread {

public void run() {

for(;;) {

System.out.println(\每3秒显示一次！\Try {

sleep(3000); }

catch(InterruptedException e){} } } }

运行结果： (这一列是注释) 每1秒显示一次 每3秒显示一次 每1秒显示一次 每1秒显示一次 每3秒显示一次 每1秒显示一次 每1秒显示一次 每1秒显示一次 每3秒显示一次 每1秒显示一次 每1秒显示一次 每1秒显示一次 每3秒显示一次

每1秒显示一次 每1秒显示一次 每1秒显示一次 每3秒显示一次 每1秒显示一次 每1秒显示一次

3、创建两个线程，每个线程打印出线程名字后再睡眠，给其它线程以执行的机会，主线程也要打印出线程名字后再睡眠，每个线程前后共睡眠5次。要求分别采用从Thread中继承和实现Runnable接口两种方式来实现程序。（即写两个程序）

/*Creats two threads that write their names and sleep. The main thread also writes its

/*name and sleeps. */

import java.io.*;

public class NameThread extends Thread{ int time; //time in milliseconds to sleep public NameThread(String n,int t){ super(n); time=t; }

public void run(){

for(int i=1;i<=5;i++){

System.out.println(getName()+\ try{

Thread.sleep(time);

}catch(InterruptedException e){return;} } }

public static void main（String args[]）{

NameThread bonnie=new NameThread(\，1000)； bonnie.start();

NameThread clyde=new NameThread(\，700)； clyde.start();

for(int i=1;i<=5;i++){

System.out.println(Thread.currentThread().getName()+\ try{

Thread.sleep(1100);

}catch(InterruptedException e){return;} } } }

第十一章 习题及思考题

1、什么是AWT，什么是Swing?

答：AWT（Abstract Window Toolkit）是Java是进行可视化开发而提供的类库。AWT提供了基本的用户接口组件，如label,button,menu,lists等。另外也提供事件处理机制，支持clipboard及数据转换（datatransfer）以及图像操作。Swing和AWT一样都是Java提供多种图形用户接口包中的抽象窗口工具组件。

2、AWT中包含了那些常用的组件，有什么用途？ 解：AWT中基本组件有：按钮（Button）、标签（Label）、复选框（Checkbox）、下拉列表框（Choice）、列表框（List）、单选框(CheckboxGroup)、单行文本框(TextField)、多行文本框(TextArea)和滚动条(Scrollbar)等。 AWT用Container类来定义最基本的容器，所有可以作为容器的窗口对象都是Container类的实例或子类所生成的对象。

AWT提供了四个容器类。它们是Window类及其两个子类、Frame类、Dia1og类和Panel类。除了AWT提供的容器外，Applet类也是一个容器，它是Panel类的一个子类。 用户创建的每个新窗口都能有它们自己的菜单条，每个菜单条可以有一定数量的菜单，菜单又可以有自己的菜单项。AWT提供了一些类用于这些组件，它们分别是MenuBar类、Menu类和MenuItem类。

java.awt软件包不仅仅包含组件，还包含与绘图和事件处理有关的类。正如我们前面所讲到的，组件是集中放置在容器中的。但我们没有提到每个容器如何使用布局管理器（Layout manager）来控制它所包含的组件尺寸和排放位置。java.awt软件提供了几个布局管理器类（BorderLayout类、CardLaout类等）。用户可根据需要选择适当的布局管理器对组件进行布局。

java.awt软件包还提供了几个类来表示尺寸和形状。例如：Dimension类，它指定了一个矩形区域的尺寸；Insets类，它通常用来指定容器的周边与容器的显示区域之间的空白大小；Shape类则包含了点、矩形和多边形。

AWT中的Color类在表示和调整颜色方面是十分有用的。它定义了一些常量来表示常用的颜色，比如，Color.black表示黑色，虽然它使用的颜色是RGB(red-green-b1ue)格式，但它也可以理解为HSB（hue-saturation-brightness）格式。

AWT中的Image类提供了图像数据的操作途径。Applet可以通过Applet的getImage()方法获得GIF(Graphic Information format)和JPEG(Joint photographic Expert Group)图像的对象，非Applet类则可以使用Toolkit类获得。Toolkit类针对AWT的平台独立性，提供了一个非独立于平台的接口。但是，大部分程序除了获得图像外，不能直接使用Toolkit对象。

用户还可以使用Font和FontMetrics类来控制所画文本的外观。Font类使用户可以获得关于字体的信息并创建不同的字体对象。FontMetrics类，使用户可以获得一些特定字体在尺寸上的细节信息。用户可以用Componet类和Graphics类的setFont()方法设置一个组件所使用的字体。

最后要提到的是Graphics类和Event类。Graphics类和Event类对于AWT的绘画及事件处理系统是非常重要的，没有Graphics对象，程序就不能往屏幕上画任何东西。而一个Event类则表示一个用户的动作，比如单击鼠标。

3、什么是事件？什么是委托事件处理模型？ 解：用户接口的作用是使程序的使用者与程序之间进行交互，如果使用户接口具有交互能力，就必须涉及到事件处理。所谓“事件”，就是指在系统中有某些我们所关心的事情（如：鼠

标移动，用户按下了某个键等）发生了，然后系统便通知我们去处理这些事情。这样的概念一般在采用图形用户界面环境的操作系统中，是十分常见的。当用户在组件上作出动作时（如：在组件上单击鼠标或按回车键），就创建了一个Event 对象。

Java事件处理模型有层次事件处理模型和委托事件处理模型。由于同一个事件源上可能发生多种事件，因此java常采取了委托处理机制(Delegation Model)，事件源可以把在其自身所有可能发生的事件分别授权给不同的事件处理者来处理。比如在Canvas对象上既可能发生鼠标事件，也可能发生键盘事件，该Canvas对象就可以授权给事件处理者一来处理鼠标事件，同时授权给事件处理者二来处理键盘事件。有时也将事件处理者称为监听器，主要原因也在于监听器时刻监听着事件源上所有发生的事件类型，一旦该事件类型与自己所负责处理的事件类型一致，就马上进行处理。委托模型把事件的处理委托给外部的处理实体进行处理，实现了将事件源和监听器分开的机制。事件处理者（监听器）通常是

一个类，该类如果要能够处理某种类型的事件，就必须实现与该事件类型相对的接口。例如例5.9中类ButtonHandler之所以能够处理ActionEvent事件，原因在于它实现了与ActionEvent事件对应的接口ActionListener。每个事件类都有一个与之相对应的接口。

4、编程包含一个标签和一个按钮，单击按钮时，标签的内容在\你好\和\再见\之间切换。 解：

import java.awt.*;

import java.awt.event.*;

class but implements ActionListener { Frame f; Label label; Button b;

public void begin()

{ f=new Frame(\ f.setSize(200,200); f.setLocation(100,100);

f.setLayout(new FlowLayout(FlowLayout.LEFT,20,20)); label=new Label(\ f.add(label);

b=new Button(\ f.add(b);

b.addActionListener(this);

f.addWindowListener(new WinClose()); f.setVisible(true); }

public void actionPerformed(ActionEvent e) { if(e.getSource()==b)

{ if(label.getText()==\ label.setText(\ else

label.setText(\ } }

}

class WinClose extends WindowAdapter

{ public void windowClosing(WindowEvent e) { System.exit(0); } }

public class work1

{ public static void main(String args[]) { (new but()).begin(); } }

5、编程包含一个复选按钮和一个普通按钮，复选按钮选中时，普通按钮的背景色为青色，未选中时为灰色。 import java.awt.*;

import java.awt.event.*;

class choose implements ItemListener { Frame f; Checkbox c; Button b;

public void begin()

{ f=new Frame(\ f.setSize(200,200);

f.setLayout(new FlowLayout()); c=new Checkbox(\ f.add(c);

b=new Button();

b.setBackground(Color.GRAY); f.add(b);

c.addItemListener(this);

f.addWindowListener(new WinClose()); f.setVisible(true); }

public void itemStateChanged(ItemEvent e)

{ if(e.getStateChange()==e.SELECTED&&b.getBackground()==Color.GRAY) b.setBackground(Color.BLUE); else

b.setBackground(Color.GRAY); } }

class WinClose extends WindowAdapter

{ public void windowClosing(WindowEvent e) { System.exit(0);

} }

public class work3

{ public static void main(String args[]) { (new choose()).begin(); } }

6、编程包含一个下拉列表和一个按钮，下拉列表中有10、14、18三个选项。选择10时，按钮中文字的字号为10，选择14时，按钮中文字的字号为14，选择18时，按钮中文字的字号为18。

import java.awt.*;

import java.awt.event.*;

class WinClose extends WindowAdapter

{ public void windowClosing(WindowEvent e) { System.exit(0); } }

class choice implements ItemListener { Frame f; Choice c; Button b;

public void begin()

{ f=new Frame(\

f.setLayout(new GridLayout()); f.setSize(300,300); c=new Choice(); c.addItem(\ c.addItem(\ c.addItem(\ f.add(c);

b=new Button(\ b.setSize(50,50); f.add(b);

f.addWindowListener(new WinClose()); c.addItemListener(this); f.setVisible(true); }

public void itemStateChanged(ItemEvent e) { String str=c.getSelectedItem(); if(str==\

b.setFont(b.getFont().deriveFont(Float.parseFloat(str))); if(str==\

b.setFont(b.getFont().deriveFont(Float.parseFloat(str))); if(str==\

b.setFont(b.getFont().deriveFont(Float.parseFloat(str))); } }

publi

c class work5 { public stati

c void main(String args[]) { (new choice()).begin(); } }

7、编程包含一个列表和两个标签，在第一个标签中显示列表中被双击的选项的内容，在第二个标签中显示列表中被选中的所有选项的内容。 import java.awt.*;

import java.awt.event.*;

class WinClose extends WindowAdapter

{ public void windowClosing(WindowEvent e) { System.exit(0); } }

class list implements ItemListener,ActionListener { Frame f;

Label lab1,lab2; List li;

public void begin() { f=new Frame(\

f.setLayout(new GridLayout()); f.setSize(400,400);

f.addWindowListener(new WinClose()); lab1=new Label(); lab2=new Label();

lab1.setSize(100,100); lab2.setSize(100,100); f.add(lab1); f.add(lab2);

li=new List(10,true); for(int i=0;i<10;i++)

li.add(String.valueOf(i)); li.addActionListener(this); li.addItemListener(this);

f.add(li);

f.setVisible(true); }

public void itemStateChanged(ItemEvent e) { String str=\

for(int row=0;row<10;row++) { if(li.isIndexSelected(row)) str=str+li.getItem(row); else

continue; }

lab2.setText(str); }

public void actionPerformed(ActionEvent e) { lab1.setText(e.getActionCommand()); } }

public class work6

{ public static void main(String args[]) { (new list()).begin(); }

8、编程确定当前鼠标的位置坐标。 import java.awt.*;

import java.awt.event.*;

class WinClose extends WindowAdapter

{ public void windowClosing(WindowEvent e) { System.exit(0); } }

class mouse implements MouseListener { Frame f; TextField t;

public void begin() { f=new Frame(\ f.setSize(200,200);

f.setLayout(new GridLayout());

f.addWindowListener(new WinClose()); t=new TextField(); f.add(t);

f.setVisible(true);

t.addMouseListener(this); }

public void mouseClicked(MouseEvent e)

本文来源：https://www.bwwdw.com/article/j2ew.html