您的当前位置：首页 java程序设计试题库

java程序设计试题库

来源：化拓教育网

《Java语言程序设计基础教程》

练习思考题参

第1章 Java程序设计概述

1.1单项选择题

1．编译Java Application源文件将产生相应的字节码文件，扩展名是什么 A. .java B. .class C. .html D. .exe 解答：B

2．Java语言具有许多优点和特点，下列选项中，哪个反映了Java中“一次编译，随处运行”的特点。 A. 简单性 C. 面向对象性解答：B

B. 平台无关性 D. 安全性

3．Java语言具有许多优点和特点，下列选项中，哪个反映了Java中并行机制的特点。

A. 多线程 C. 面向对象性解答：A

B. 平台无关性 D. 安全性

4．在Java语言中，下列哪些语句关于内存回收的说明是正确的? A．程序员必须创建一个线程来释放内存； B．内存回收程序负责释放无用内存；

C．内存回收程序允许程序员直接释放内存；

《Java语言程序设计基础教程》

D．内存回收程序可以在指定的时间释放内存对象解答：B

5．一个Java源文件中最多只能有多少个public类。 A. 1个 B. 2个 C. 3个 D. 任意多个解答：A

6．下面哪一个不是Java语言所具有的特点。

A. 没有全局变量，在类的定义外部没有任何的变量定义； B. 不直接支持指针操作，而使用更安全的引用类型； C. 支持子类对父类的多继承； D. 具有自动垃圾收集功能；解答：C

7．下面哪一个不是Java开发工具包JDK的组成部分。 A. Java的编译器； B. Java的解释器；

C. Java的API继承类库； D. Eclipse开发工具；解答：C

8．JDK提供的编译器是（）。 A. java.exe B. javac.exe C. javap.exe D. javaw.exe 解答：B

9．作为Java应用程序入口的main方法，其声明格式可以是（） A. public void main(String [] args)

B. public static void main(String [] args) C. public static void Main(String * args) D. public int main(String [] args)

《Java语言程序设计基础教程》

解答：B

10．下列说法正确的是（ A ）

A、 JAVA程序的main方法必须写在类里面 B、 JAVA程序中可以有多个main方法 C、 JAVA程序中类名必须与文件名一样

D、 JAVA程序的main方法中如果只有一条语句，可以不用{}(大括号)括起来

11．下列哪些语句关于Java内存回收的说明是正确的? （ B ） A、程序员必须创建一个线程来释放内存 B、内存回收程序负责释放无用内存

C、内存回收程序允许程序员直接释放内存

D、内存回收程序可以在指定的时间释放内存对象

1.2填空题

1、开发与运行Java程序需要经过的三个主要步骤为____________、____________和____________。

解答：编辑源程序、编译生成字节码和解释运行字节码

2、使用Java编译器___ javac____.exe编译源文件得到字节码文件。

3、Java应用程序必须通过Java解释器__JAVA__.exe来解释执行其字节码文件。

4、如果Java源文件中有一个类是public类，那么源文件的名字必须与这个类的名字完全_相同______，扩展名是.java 。

5、Java应用程序总是从主类的____main___方法开始执行．

1.3简答题

13.简述Java程序的开发过程？

《Java语言程序设计基础教程》

（1）使用一个文字编辑器，编写源文件。（2）使用java编译器，编译源文件得到字节码文件。

（3）解释运行字节码，分两种java应用程序必须通过java解释器来解释执行，java小应用程序必须使用解释器和浏览器运行程序。

1.什么是Java虚拟机？为什么Java被称作是“平台无关的编程语言”？解答：

Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件。

Java被设计成允许应用程序可以运行在任意的平台，而不需要程序员为每一个平台单独重写或者是重新编译。Java虚拟机让这个变为可能，因为它知道底层硬件平台的指令长度和其他特性。

3.Java语言的关键特点有哪些？解答：简单性平台无关性面向对象性安全性分布式多线程动态性

1.4综合题

第2章 Java基本的程序设计结构

2.1单项选择题

1、下面哪一项在java中是非法的标识符？（）

A. $user B. point C. You&me D. _endline 解答：Ｃ

《Java语言程序设计基础教程》

2、若有定义 int a=9,b=6; 那么a>b的值是：（）

A. 0 B. 1 C. false D. true 解答：D

3、执行完以下代码int[ ] x = new int[25];后，以下说明正确的是：（）

A. x[24]为0 B. x[24]未定义 C. x[25]为0 D. x[0]为空解答：A

4、Java应用程序的main方法中有以下语句，则输出的结果是（ int[] x={2,3,-8,7,9}; int max=x[0];

for(int i=1;iif(x[i]>max) max=x[i]; }

System.out.println(max); A. 2 B. -8 C. 7 D. 9 解答：Ｄ

5、设 x = 1 , y = 2 , z = 3，则表达式 y＋＝z－－/＋＋x 的值是（ A. 3 B. 3.5 C. 4 D. 5 解答：A

5、执行System.out.println(5/4)，这条代码的输出结果是（）

A. 1 B. 1.25 C. 1.5 D. 0 解答：A

6、下列语句有错误的是：（）

A. int []a; B. int []b=new int[10]; C. int c[]=new int[]; D. int d[]=null; 解答：C

7、下列语句有错误的是：（）

A. int a[][]=new int[5][5]; B. int [][]b=new int[5][5]; C. int []c[]=new int[5][5]; D. int [][]d=new int[5,5]; 解答：D

8、下列哪一个不属于Java中的8种基本数据类型（）

A. double; B.char; C. int; D. String;

。

）

） 6

《Java语言程序设计基础教程》

解答：D

9、以下数据类型存储空间最大的是（）。

（A）byte （B）long （C）float （D）char 解答：B

10、System.out.println(\"5\" + 2);的输出结果应该是（）。

A 52 B7 C2 D5 答案：A 11．在类的定义中可以有两个同名方法，每个方法的参数不同，这种现象称为方法（D ）。

（A）封装（B）继承（C）覆盖（D）重载

12．java中定义字符串String s=”pzhu”,下面操作可以取得字符串长度的是（）。

A. s.length() B. s.length C. s.size() D. length(s) 解答：A

13．指出下列程序运行的结果（B）(很难) public class Example {

String str = new String(\"good\");

char[] ch = { 'a', 'b', 'c' };

public static void main(String args[]) {

Example ex = new Example();

ex.change(ex.str, ex.ch);

System.out.print(ex.str + \" and \");

System.out.print(ex.ch);

}

public void change(String str, char ch[]) {

str = \"test ok\";

ch[0] = 'g';

} }

《Java语言程序设计基础教程》

A、 good and abc B、 good and gbc C、 test ok and abc D、 test ok and gbc

14．下面代码的运行结果为：（C）(较难) import java.io.*; import java.util.*;

public class foo{

public static void main (String[] args){

String s;

System.out.println(\"s=\" + s);

} }

A 代码得到编译，并输出“s=” B 代码得到编译，并输出“s=null”

C 由于String s没有初始化，代码不能编译通过

D 代码得到编译，但捕获到 NullPointException异常

15．关于以下程序段，正确的说法是（ C ） 1． String s1=”abc”+”def”; 2． String s2=new String（s1）； 3． if（s1= =s2）

4． System.out.println(“= = succeeded”); 5． if (s1.equals(s2))

6． System.out.println(“.equals() succeeded”); A、行4与行6都将执行 B、行4执行，行6不执行

C、行6执行，行4不执行 D、行4、行6都不执行

16．Java application中的主类需包含main方法，main方法的返回类型是什么？（A、int B、float C、double D、void

D ） 7

《Java语言程序设计基础教程》

17．为一个boolean类型变量赋值时，可以使用(B )方式 A、 boolean = 1;

B、 boolean a = (9 >= 10); C、 boolean a=\"真\"; D、 boolean a = = false;

18．表达式(11+3*8)/4%3的值是( D ) A、 31 B、 0 C、 1 D、 2

19．运算符优先级别排序正确的是（ A）（太难）

A、由高向低分别是：()、!、算术运算符、关系运算符、逻辑运算符、赋值运算符； B、由高向低分别是：()、关系运算符、算术运算符、赋值运算符、!、逻辑运算符； C、由高向低分别是：()、算术运算符、逻辑运算符、关系运算符、!、赋值运算符； D、由高向低分别是：()、!、关系运算符、赋值运算符、算术运算符、逻辑运算符；

20．下列值不为true的表达式有（C ）。 A、 \"john\" = = \"john\" B、 \"john\".equals(\"john\") C、 \"john\" = \"john\"

D、 \"john\".equals(new String(\"john\"))

21、下面的方法，当输入为2的时候返回值是多少?（D）(很难) public static int getValue(int i) { int result = 0; switch (i) { case 1:

result = result + i; case 2:

result = result + i * 2; case 3:

result = result + i * 3; }

return result; }

A0 B2 C4 D10

答案：D

解析：注意这里case后面没有加break，所以从case 2开始一直往下运行。

《Java语言程序设计基础教程》

22、下面有关for循环的描述正确的是（ A ）

A、 for循环体语句中，可以包含多条语句，但要用大括号括起来 B、 for循环只能用于循环次数已经确定的情况 C、在for循环中，不能使用break语句跳出循环 D、 for循环是先执行循环体语句，后进行条件判断

23、score是一个整数数组，有五个元素，已经正确初始化并赋值，仔细阅读下面代码，程序运行结果是（ B ）

temp = score[0];

for (int index = 1;index < 5;index++) { if (score[index] < temp) { temp = score[index]; } }

A. 求最大数 B. 求最小数 C. 找到数组最后一个元素 D. 编译出错 26、

2.2填空题

1、Java语言是一种完全的_面向对象 _程序设计语言

2、String s1=“China”; int n=s1.length( ); n的值为_5__

3、在Java语言中，基本数据类型包括：____整数类型、____浮点类型、____字符类型_和____布尔类型

17、在Java的基本数据类型中，char型采用Unicode编码方案，每个Unicode码占用__2___字节内存空间，这样，无论是中文字符还是英文字符，都是占用__2___字节内存空间。

《Java语言程序设计基础教程》

18、设 x = 2 ，则表达式 ( x + + )／3 的值是__0___。

20、设有数组定义：

int MyIntArray[] = { 10, 20, 30, 40, 50, 60, 70 };

则执行以下几个语句后的输出结果是： 120 。 int MyIntArray[] = { 10, 20, 30, 40, 50, 60, 70 }; int s = 0; for (int i = 0; i < MyIntArray.length; i++) if (i % 2 == 1) s += MyIntArray[i]; System.out.println(s);

21、数组对象的长度在数组对象创建之后，就__不会____改变。数组元素的下标总是从___0___开始。

22、对于数组int[][]t={{1,2,3},{4,5,6}}来说，t.length等于__2___，t[0].length等于__3____。

2.3简答题

1、Java的基本数据类型有哪8种，每种类型的内存空间分别是多少。

2.4综合题

26、编程计算10~20的整数的平方值，将结果保存在一个数组中。

27、编写一个程序使之从键盘读入10个整数存入整型数组a中，并输出这10个整数的最大值和最小值。

import java.util.Scanner; public class lianxi30 {

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

float[] sum = new float[11]; float max, min;

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

System.out.println(\"请输入第一个数字(回车结束)：\"); temp = new Scanner(System.in); String a = temp.nextLine();

《Java语言程序设计基础教程》

sum[i] = Integer.parseInt(a); //获取输入的字符串 }

max = sum[0]; min = sum[0];

for (int j = 1; j < 10; j++) {

if (max < sum[j]) max = sum[j];

else if (min > sum[j]) min = sum[j]; }

System.out.println(max); System.out.println(min); } }

31、如果我国经济以每年10%的速度保持稳定增长，请编写一个程序，计算每年达到多少，多少年可以实现总量翻两番。

class exA4_1{

public static void main(String args[]){ int a=0;

double i=0.10,sum=1; while(sum<=4){ sum=(i+1)*sum; a++;

System.out.println(\"第\"+a+\"年达到\"+sum); }

System.out.println(\"需要\"+a+\"年实现两番\"); } }

《Java语言程序设计基础教程》

第3章类和对象

3.1单项选择题

1、下列关于变量的叙述哪个是错的？（）

A. 实例变量是类的成员变量。

B. 在方法中定义的局部变量在该方法被执行时创建。 C. 实例变量用关键字static声明。 D. 局部变量在使用前必须被初始化。解答：C

2、在Java语言中，下列哪个包是编译器自动导入的？（）

A. java.applet B. java.lang C. java.io D. java.awt 解答：Ｂ

6、不允许作为类及类成员的访问控制符的是（）。

A. public B. private C. static D. protected 解答：C 7、为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为（）。

A、 static void method( ) B、 public void method( ) C、 final void method( ) D、 abstract void method( ) 解答：A

8、可以在下面代码段point x处写入的是？（）

//point x

public class Interesting{ //do something }

A. String str;

B. static int PI=3.14;

C. public class MyClass{//do other thing…} D. import java.awt.*; 解答：D

9、Java提供的许多类在不同的包中，使用下面哪个语句可以引入包中的类。

《Java语言程序设计基础教程》

A. package B. include C. import D. add 解答：C

11、已知A类被打包在packageA , B类被打包在packageB ，且B类被声明为public ，且有一个成员变量x被声明为protected控制方式。C类也位于packageA包，且继承了B类。则以下说法正确的是：（）

A、A类的实例不能访问到B类的实例

B、A类的实例能够访问到B类一个实例的x成员 C、C类的实例可以访问到B类一个实例的x成员 D、C类的实例不能访问到B类的实例解答：C（太难）

13、在Java中，关于final关键字的说法正确的是（）

A、如果修饰变量，则一旦赋了值，就等同一个常量。 B、如果修饰类，则该类只能被一个子类继承。 C、如果修饰方法，则该方法不能在子类中被覆盖。 D、如果修饰方法，则该方法所在的类不能被继承。解答：A,C

14、关于构造方法以下说法错误的是 ( D )。

（Ａ）构造方法名必须与类名一致（Ｂ）构造方法可以重载

（Ｃ）构造方法是通过new来调用（Ｄ）每个类都必须编写构造方法代码15、关于类的定义以下说法错误（ B ）。

（A）类定义使用class关键字（B）每个类中必须有一个main方法（C）一个包可以包含多个类（D）java中所有类都是Object类的子类 16、在创建对象时必须（C）

A) 先声明对象，然后才能使用对象

B) 先声明对象，为对象分配内存空间，然后才能使用对象

C) 先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象 D) 上述说法都对

17、在调用方法时，若要使方法改变实参的值，可以（B）

A) 用基本数据类型作为参数 B) 用对象作为参数 C) A和B都对 D) A和B都不对 18、关于以下程序代码的说明正确的是（ D ） class HasStatic{ private static int x=100; public static void main(String args[ ]){ HasStatic hs1=new HasStatic( ); hs1.x++; HasStatic hs2=new HasStatic( );

《Java语言程序设计基础教程》

hs2.x++; hs1=new HasStatic( ); hs1.x++; HasStatic.x- -; System.out.println(“x=”+x); } }

A、 5行不能通过编译，因为引用了私有静态变量 B、 10行不能通过编译，因为x是私有静态变量 C、程序通过编译，输出结果为：x=103 D、程序通过编译，输出结果为：x=102

19、以下关于构造函数的描述错误的是（ A ）。 A、构造函数的返回类型只能是void型。

B、构造函数是类的一种特殊函数，它的方法名必须与类名相同。 C、构造函数的主要作用是完成对类的对象的初始化工作。 D、一般在创建新对象时，系统会自动调用构造函数。

20、Java中，在如下所示的Test类中，共有（C ）个构造方法。 public class Test{ private int x;

public Test(){ x=35; }

public void Test(double f){ This.x=(int)f; } public Test(String s){} }

A、 0 B、 1 C、 2 D、 3

21、在Java中,关于构造方法，下列说法错误的是( C ) A、构造方法的名称必须与类名相同 B、构造方法可以带参数 C、构造方法不可以重载

D、构造方法绝对不能有返回值

22、在Java语言中，下列关于类的继承的描述，正确的是（B ）。 A、一个类可以继承多个父类 B、一个类可以具有多个子类 C、子类可以使用父类的所有方法 D、子类一定比父类有更多的成员方法

《Java语言程序设计基础教程》

23、分析选项中关于Java中this关键字的说法正确的是（ A ） A、 this关键字是在对象内部指代自身的引用 B、 this关键字可以在类中的任何位置使用

C、 this关键字和类关联，而不是和特定的对象关联 D、同一个类的不同对象共用一个this

24、在Java接口中，下列选项中有效的方法声明是（ A ）。 A、 public void aMethod();

B、 public final void aMethod(); C、 protected void aMethod(); D、 private void aMethod();

25、下列选项中关于Java中super关键字的说法正确的是（A ）。 A、 super关键字是在子类对象内部指代其父类对象的引用

B、 super关键字不仅可以指代子类的直接父类，还可以指代父类的父类 C、子类通过super关键字只能调用父类的方法，而不能调用父类的属性 D、子类通过super关键字只能调用父类的属性，而不能调用父类的方法

3.2填空题

1、在Java程序中，通过类的定义只能实现____单重继承____，但通过接口的定义可以实现多____多重继承____。

2、_抽象（abstract）___方法是一种仅有方法头，没有具体方法体和操作实现的方法，该方法必须在抽象类之中定义。__final____方法是不能被当前类的子类重新定义的方法。

3、面向对象程序设计的三个特征是_____封装、____多态、____继承

4、Java是面向对象语言，类是客观事物的_抽象____，而对象是类的_实例____。

5、如果在子类中想使用被子类隐藏的父类成员变量或方法，就可以使用关键字__ super_____。

6、Java中有一种叫作___构造方法__的特殊方法用来对类的对象成员进行初始化。

7、JAVA语言中提供了两种类型的字符串类来处理字符串，它们是___String_和___StringBuffer类

《Java语言程序设计基础教程》

8、Java语言中，所有的类都是___Object的子类，Java的窗口通常是___JFrame__的子类，___抽象_类只能定义但不能被实例化，_ 最终_类不能被继承

9、一般Java程序的类体由两部分组成：一部分是_属性_，另一部分是_方法_

10、分别用__class_关键字来定义类，用_new__关键字来分配实例存储空间。

11、Java中类成员的限定词有以下几种：__ private_ _, public __ _, protected __ _, _缺省_ _。其中，_public __的限定的范围最大。类中限定为_ private __的成员，只能被这个类本身内部访问。

12、Java类中，如果类的定义者没有显式的定义任何构造方法，系统将自动提供一个___无参默认_构造方法。

13、在子类中定义与父类的相同的方法,若在多个子类中定义相同的方法,则可以调用不同子类中的相同方法而实现不同的功能,这实现了程序运行时的______ 多态。

3.3简答题

1. 简单阐述方法的重载和方法的重写之间的区别解答：

重写是子类的方法覆盖父类的方法，要求方法名和参数都相同

重载是在同一个类中的两个或两个以上的方法，拥有相同的方法名，但是参数却不相同

2、简述实例变量和类变量的区别。

解答：类变量也叫静态变量，也就是在变量前加了static 的变量；实例变量也叫对象变量，即没加static 的变量；

区别在于：类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象；

2、简述实例方法和类方法的区别

解答：实例方法可以对当前对象的实例变量进行操作，也可以对类变量进行操作，实例方法由实例对象调用。但类方法不能访问实例变量，只能访问类变量。类方法可以由类名直接调用，也可由实例对象进行调用。类方法中不能使用this或super关键字。

3、面向对象的三个基本特征是什么，分别简单介绍每个特征。

《Java语言程序设计基础教程》

解答：三大特性是：封装，继承，多态。

封装性就是把对象的属性和服务结合成一个的单位，并尽可能隐蔽对象的内部细节。

特殊类的对象拥有其一般类的全部属性与服务，称作特殊类对一般类的继承。

对象的多态性是指在一般类中定义的属性或服务被特殊类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或服务在一般类及其各个特殊类中具有不同的语义。

4、简单阐述成员变量和局部变量的区别。解答：

1)成员变量在整个类内都有效，局部变量只在定义它的方法内有效。

2)成员变量又分为实例成员变量（简称实例变量）和类变量（也称静态变量），如果成员变量的类型前面加上关键字static，这样的成员变量称为类变量或静态变量。

3)如果局部变量的名字与成员变量的名字相同，则成员变量被隐藏，也就是说，这个成员变量在这个方法内暂时失效。这时如果想在该方法内使用成员变量，必须使用关键字this。

5、简述对象的引用和实体。

解答：当用类创建一个对象时，类中的成员变量被分配内存空间，这些内存空间称为该对象的实体，而对象中存放着引用，以确保实体由该对象操作使用。没有实体的对象称为空对象，空对象不能使用，即不能让一个空对象去调用方法产生行为。

6、简述this关键字的意义，以及它在成员方法和构造方法中如何使用。

解答：this是Java的一个关键字，表示某个对象。this可以出现在实例方法和构造方法中，但不可以出现在类方法中。this可以出现在实例方法和构造方法中，但不可以出现在类方法中。this关键字出现在类的构造方法中时，代表使用该构造方法所创建的对象。实例方法必须通过对象来调用，当this关键字出现在类的实例方法中时，代表正在调用该方法的当前对象。

成员函数中定义了和成员变量中相同的变量时，引用成员变量要用this;构造函数中调用同一个类的其他构造函数时用this。

7、简单描述Java的参数传值中的两种方式，基本数据类型参数的传值和引用类型参数的传值？

解答：在基本数据类型参数的传值中，基本数据类型的参数向该参数传递的值的级别不可以高于该参数的级别。

在引用类型参数的传值中，Java的引用类型数据包括对象、数组和接口，当参数是引用类型时，“传值”传递的是变量的引用而不是变量所引用的实体。如果改变参数变量所引用的实体，就会导致原变量的实体发生同样的变化，但是如果改变参数的引用不会影响向其传值的变量的引用。

《Java语言程序设计基础教程》

8、基本数据类型和对象作为参数传递的不同？解答：

（1）基本数据类型作为参数在方法中传递的是值传递。

（2）对象是引用传递，当对象作为参数传递时，传递的是对象的地址。

3.4综合题

1、定义一个“点”(Point)类用来表示三维空间中的点，类体的成员变量x,y,z分别表示三维空间的坐标。类体中具有如下成员方法的定义：

1）构造方法Point（）可以生成具有特定坐标的点对象。 2）setX()， setY()， setZ()为可以设置三个坐标的方法。 3.）getDistance()为可以计算该点距离原点距离平方的方法。解答： class Point{ double x,y,z ; Point(double _x,double _y,double _z) { x = _x ; y = _y ; z =_z ; } void setX(double _x){ x=_x ; } void setY(double _y){ y=_y ; } void setZ(double _z){ z=_z ; } double getDistance(){ return ( x*x+y*y+z*z) ; } }

《Java语言程序设计基础教程》

2、编写一个Java应用程序Test类，实现成员方法max(a,b)的重载。具体要求如下：

a) 编写void max(int a,int b)成员方法，对两个整数进行大小的比较，输出打印较大的那个整数。

b) 编写void max(float a,float b)成员方法，对两个float数进行大小的比较，输出打印较大的那个float数。

c) 编写void max(double a,double b)成员方法，对两个double数进行大小的比较，输出打印较大的那个double数。 public class Test{ void max(int a,int b){ System.out.println(a>b ? a:b) ; } void max(float a,float b){ System.out.println(a>b ? a:b) ; } void max(double a, double b){ System.out.println(a>b ? a:b) ; } public static void main(String[] args){ Test t =new Test() ; t.max(3,4) ; } } 3、编写一个矩形类对数学中的矩形进行抽象描述，并具有方法可以计算矩形的周长和面积，具体分为以下三个子任务完成。

（1）创建Rectangle类，添加属性width、height，并定义构造方法Rectangle(double _width, double _height)；（2）在Rectangle类中添加两种方法computCircum()和computArea()分别计算矩形的周长和面积；

（3）编程利用Rectangle对象输出一个30*40的矩形的周长和面积。解答：

public class TestRectang {

public static void main(String[] args) {

// TODO Auto-generated method stub Rectangle rect1 = new Rectangle(20,30) ;

}

class Rectangle{ }

double computArea() { }

Rectangle(){ }

width = 0 ; height = 0 ; double width,height ; }

《Java语言程序设计基础教程》

System.out.println(rect1.computArea()); System.out.println(rect1.computCircum());

Rectangle(double _width,double _height){ }

width = _width ; height = _height ;

return width*height ;

double computCircum(){ }

return 2*(width+height) ;

第4章继承、接口和内部类

4.1单项选择题

1、 Java中用于定义接口的关键字是（）

A、import B、package C、class D、interface 解答：D

2、以下关于abstract的说法，正确的是( )

《Java语言程序设计基础教程》

A、abstract只能修饰类 B、abstract只能修饰方法

C、abstract类中必须有abstract方法

D、abstarct方法所在的类必须用abstract修饰解答：D

3、下列哪种说法是正确的（）

A、私有方法不能被子类覆盖。

B、子类可以覆盖超类中的任何方法。

C、覆盖方法可以声明自己抛出的异常多于那个被覆盖的方法。 D、覆盖方法中的参数清单必须是被覆盖方法参数清单的子集。解答：A

4、关于类继承的说法，正确的是（）

A、Java 类允许多重继承 B、Java接口允许多继承 C、接口和类都允许多继承 D、接口和类都不允许多继承解答：B

5、关于抽象类，正确的是______。

A. 抽象类中不可以有非抽象方法

B. 某个非抽象类的父类是抽象类，则这个子类必须重载父类的所有抽象方法C. 可以用抽象类直接去创建对象 D. 接口和抽象类是同一个概念解答：B

8、抽象类A和抽象类B的定义如下：

abstract class A { abstract int getinfo(); }

public class B extends A { private int a = 0; public int getinfo() { return a; } public static void main(String args[]) { B b = new B(); System.out.println(b.getinfo()); } }

关于上述代码说明正确的是（）。

《Java语言程序设计基础教程》

A. 输出结果为0 B.通过编译但没有输出任何结果 C. 第5行不能通过编译 D. 程序第2行不能通过编译解答：A

9、下面程序的运行结果是______

class ex4_5_11_A { protected static int count = 0; public ex4_5_11_A() { count++; } }

class ex4_5_11_B extends ex4_5_11_A { public ex4_5_11_B() { count++; } }

class ex4_5_11 { public static void main(String args[]) { ex4_5_11_B x = new ex4_5_11_B(); System.out.println(\"count=\" + x.count); } }

A. count=1 B. count=2 C. count=3 D. count=4 解答：B

10、设有下面两个类的定义：

class Person

{ long id; // 身份证号

String name; // 姓名 }

class Student extends Person { int score; // 入学总分

int getScore(){

return score; } }

问：类Person和类Student的关系是（）

A、包含关系 B、继承关系 C、关联关系 D、无关系，上述类定义有语法错误

《Java语言程序设计基础教程》

解答：B

11、以下程序代码错误的是（ B ）。 abstract class P{} class A extends P{}

abstract class B extends P{}

（Ａ）P p=new A(); （Ｂ）P p=new B();

（Ｃ）A a=new A(); （Ｄ）P p=new P(){void foo(){}};

12、下面是People和Child类的定义和构造方法，每个构造方法都输出编号。在执行new Child(\"mike\")的时候都有哪些构造方法被顺序调用？请选择输出结果 ( D)

class People { String name;

public People() {

System.out.print(1); }

public People(String name) { System.out.print(2); this.name = name; } }

class Child extends People { People father;

public Child(String name) { System.out.print(3); this.name = name;

father = new People(name + \":F\"); }

public Child() {

System.out.print(4); } }

A312 B 32 C 432 D 132

《Java语言程序设计基础教程》

13、选项中哪一行代码可以替换题目中//add code here而不产生编译错误？（A） public abstract class MyClass {

public int constInt = 5; //add code here

public void method() { } }

A public abstract void method(int a); B constInt = constInt + 5; C public int method();

D public abstract void anotherMethod() {}

15、以下哪项是接口的正确定义？（ D ） A、 interface B { void print() { } } B、 abstract interface B { void print() }

C、 abstract interface B extends A1,A2 //A1、A2为已定义的接口

{ abstract void print(){ };}

D、 interface B { void print();}

16、A派生出子类B，B派生出子类C，并且在Java源代码中有如下声明： 1. A a0=new A(); 2. A a1 =new B(); 3. A a2=new C();

问以下哪个说法是正确的？（ D ） A、只有第1行能通过编译

B、第1、2行能通过编译，但第3行编译出错

C、第1、2、3行能通过编译，但第2、3行运行时出错 D、第1行、第2行和第3行的声明都是正确的

17、假设A类有如下定义，设a是A类的一个实例，下列语句调用哪个是错误的？（ C ）

class A { int i;

static String s;

void method1() { }

static void method2() { } }

《Java语言程序设计基础教程》

A、System.out.println(a.i)； B、a.method1(); C、A.method1(); D、A.method2()

18、以下关于继承的叙述正确的是（ A ）。 A、在Java中类只允许单一继承

B、在Java中一个类只能实现一个接口

C、在Java中一个类不能同时继承一个类和实现一个接口 D、在Java中接口只允许单一继承

19、以下关于抽象类和接口的说法错误的是（E ）

A、抽象类在Java语言中表示的是一种继承关系，一个类只能使用一次继承。但是一个类却可以实现多个接口。

B、在抽象类中可以没有抽象方法

C、实现抽象类和接口的类必须实现其中的所有方法，除非它也是抽象类。接口中的方法都不能被实现

D、接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。

E、接口中的方法都必须加上public关键字。

4.2填空题

1、在Java语言中所有的类都是直接或间接地继承_ Object _____类而得到的。

2、在Java中一个父类可以有___多___个子类，一个类只能有__一____个直接父类。 3、Java中不能被实例化、只能被子类继承的是____抽象_____ 类

4、当子类中的变量或方法与父类的变量和方法重名时,子类的变量被______ 隐藏,子类中的方法被______ 重载。此时,指向父类中的变量或方法，则用 ______ super 关键字实现。

5、用来定义一个类指定继承父类的关键字是______ extends ,用来指定接口的继承的关键字是______implements

7、在已有类的基础上构造一个新的类，称为类的______ 继承。

《Java语言程序设计基础教程》

4.3简答题

1、请举例简要说明JAVA语言的继承机制有何特点？

解答：子类可以使用父类中的成员变量和方法，然后也可以添加自己的属性和方法。如果子类没有构造方法，则编译器首先为子类添加一个无参的构造方法，然后调用父类的默认构造方法，如果子类有构造方法，则先调用父类的默认构造方法，再调用子类的构造方法；如果父类中没有默认构造方法，则出错。（太难）

2、什么是继承？什么是多重继承和单继承？Java采用何种机制来实现多重继承？解答：继承是面向对象编程的一种特性，是保留原有类功能的前提下拓展或改写部分功能，实现代码复用的方式。单继承就是一个类只可以继承自一个父类，多继承是指一个类可以同时继承多个父类。java中使用的是单继承，也就是一个类有且只能有一个父类，java中可以使用接口实现来实现类似多继承的效果。

3、简述super关键字的意义，以及如何使用。

解答：关键字super表示父类对象。通过在子类中使用super做前缀可以引用被子类隐藏的父类变量或被子类重写的父类方法。super用来引用当前对象的父类，虽然构造方法不能够继承，但利用super关键字，子类构造方法中也可以调用父类的构造方法。1)操作被隐藏的变量和方法;2)使用super调用父类的构造方法。

4、抽象类是什么，抽象方法是什么。

解答：抽象类就是不能使用new方法进行实例化的类，即没有具体实例对象的类。抽象类有点类似“模板”的作用，目的是根据其格式来创建和修改新的类。对象不能由抽象类直接创建，只可以通过抽象类派生出新的子类，再由其子类来创建对象。

抽象方法就是以abstract修饰的方法，这种方法只声明返回的数据类型、方法名称和所需的参数，没有方法体，也就是说抽象方法只需要声明而不需要实现。当一个方法为抽象方法时，意味着这个方法必须被子类的方法所重写，否则其子类的方法仍然是abstract的。

4、接口是什么，以及它的用处体现在哪几个方面。

解答：接口是抽象类的一种，只包含常量和方法的定义，而没有变量和方法的实现，且其方法都是抽象方法。它的用处体现在下面几个方面： 1)通过接口实现不相关类的相同行为，而无需考虑这些类之间的关系。2)通过接口指明多个类需要实现的方法。 3)通过接口了解对象的交互界面，而无需了解对象所对应的类。

5、什么是接口，什么是抽象类，接口和抽象类的区别？解答：

抽象类就是不能使用new方法进行实例化的类，即没有具体实例对象的类。抽象类有点类似“模板”的作用，目的是根据其格式来创建和修改新的类。对象不能由抽象类直接

《Java语言程序设计基础教程》

创建，只可以通过抽象类派生出新的子类，再由其子类来创建对象。

接口是抽象类的一种特殊形式，只包含常量和方法的定义，而没有变量和方法的实现，且其方法都是抽象方法。

抽象层次不同,抽象类是对类的抽象，而接口是对行为的抽象。

跨域层次不同，抽象类的跨域是具有相似的类，接口可以跨域不同的类。

设计层次不同，抽象类是自底向上抽象而来，子类抽象父类接口是自顶向下设计的，无需知道子类。

6、接口的用处体现哪几个方面？解答：

通过接口实现不相关类的相同行为，而无需考虑这些类之间的关系。通过接口指明多个类需要实现的方法。

通过接口了解对象的交互界面，而无需了解对象所对应的类。

7、接口与实现类（具体类）关系：解答：

多个无关的类可以实现同一个接口。一个类可以实现多个无关的接口。

与继承关系类似，接口与实现类之间存在多态性。

14、子类与父类的继承关系中，什么是属性隐藏？什么是方法重写？

解答：隐藏是指当父类和子类有相同名字的属性的时候，父类的同名变量形式上不可见了。但是实际还是存在的。

重写是针对方法的，通常是父类的方法在子类中重新写过。当执行子类的实例得时候，实际运行的是子类的方法。在子类里面可以通过super.method（）来显式的访问。

15、子类会继承父类的所有方法和属性么？

解答：在同一个包中除private声明外的方法都可以继承。不在同一个包中，只继承protected和public声明的方法。（太难了）

16、Java中的方法重写(Overriding)和方法重载(Overloading)分别是什么？

解答：Java中的方法重载发生在同一个类里面两个或者是多个方法的方法名相同但是参数不同的情况。与此相对，方法重写是说子类重新定义了父类的方法。子类中重写的方法和父类中被重写的方法必须有相同的方法名，参数列表和返回类型，只是方法体不同。

《Java语言程序设计基础教程》

4.4综合题

1、写出一个类People，并由该类做基类派生出子类Employee和Teacher。其中People 类具有name、age两个保护成员变量，分别为String类型、整型，且具有公有的getAge成员函数，用于返回age变量的值。Employee类具有保护成员变量empno为String类型,Teacher类有teano为String类型和zc成员变量为String类型。

解答：

//People类：

public abstract class People { protected String name; protected int age; public int getAge() { return age; } }

//Employee类：

public class Employee extends People { protected String empno; }

//Teacher类：

public class Teacher extends People { protected String teano; protected String zc; }

2、定义一个新的类Student类，继承Person类。要求： 1）增加“school”属性为String类型。

2）重载Student类的构造方法，Student(String n,String l,String school)。 3）重写Person类的info()方法，增加school信息。 class Person{ private String name; private String location; Person(String name, String location){ this.name =name; this.location =location ; }

《Java语言程序设计基础教程》

public String info(){ return \"name:\"+name+\"location:\"+location ; } }

解答：

class Student extends Person{ private String school ; Student(String n,String l,String school){ super(n,l); this.school = school ; } public String info(){ return super.info()+\"school:\"+school ; } }

3、定义一个接口，该接口中只有一个抽象方法getClassName()。设计一个类Horse，该类实现接口ClassName中的方法getClassName()，功能是获取该类的类名。

interface Classname { public String getclassname(); }

class Horse implements Classname { public String getclassname() { return this.getClass().getName(); } }

public class Test { public static void main(String[] args) { Classname name = new Horse(); System.out.println(name.getclassname()); } }

4、编写一个Java应用程序，该程序中有1个Cat类继承Object类，具有三个成员属性String name、int furColor、int height，一个构造方法Cat(String name,int furColor,int height)，

《Java语言程序设计基础教程》

并且重写Cat类的toString()和equals(Object obj)成员方法。具体要求如下：

a) 重写toString成员方法，返回值是成员属性String name的值。 b) 重写equals成员方法，如果两个Cat对象的furColor和height属性相等那么返回值是true，否则返回值是false。

class Cat{ int color ; int height,weight ; public Cat(String name,int color,int height,int weight){ this.name=name ; this.color = color ; this.height = height ; this.weight = weight ; } public String toString(){ return this.name; } public boolean equals(Object obj){ if(obj==null) return false ; else{ if(obj instanceof Cat){ Cat c =(Cat) obj ; if(c.color==this.color && c.height==this.height) return true ; } } return false ; } }

18. 定义一个动物类Animal，具有name成员变量，构造方法和sing()方法。定义一个Cat类继承Animal类，增添furColor成员变量，重写构造方法和sing()方法。定义一个Bird类继承Animal类，增添featherColor成员变量，重写构造方法和sing()方法。在main方法中接收用户的输入\"1.Cat 2.Bird\"创建Cat或者Bird对象，并把该对象的引用赋值给一个Animal引用变量pet，最后调用引用变量pet的方法sing()，并将结果输出。

package com.pm.Poly; class Animal{

《Java语言程序设计基础教程》

private String name ; Animal(String name){ this.name =name ; } public void enjoy(){ System.out.println(\"叫声....\"); } }

class Cat extends Animal{ private String eyesColor ; Cat(String n,String c){ super(n) ; eyesColor = c ; } public void enjoy(){ System.out.println(\"猫叫声....\"); } }

class Dog extends Animal{ private String furColor ; Dog(String n,String c){ super(n) ; furColor = c ; } public void enjoy(){ System.out.println(\"狗叫声....\"); } }

class Bird extends Animal{ private String featherColor ; Bird(String n,String f){ super(n) ; featherColor=f ;

《Java语言程序设计基础教程》

} public void enjoy(){ System.out.println(\"鸟叫声.....\"); } }

class Lady{ private String name; private Animal pet ; Lady(String name,Animal pet){ this.name =name ; this.pet =pet ; } public void myPetEnjoy(){ pet.enjoy(); } }

public class TestPolymoph { public static void main(String[] args) { // TODO Auto-generated method stub Lady l3 = new Lady(\"l3\ l3.myPetEnjoy() ; } }

第5章 Java API

5.1单项选择题

2、仔细分析下面程序，正确的输出结果是（）

public class Test1 {

《Java语言程序设计基础教程》

public static void changeStr(String str) { str = \"welcome\"; } public static void main(String[] args) { String str = \"1234\"; changeStr(str); System.out.println(str); } }

A、welcome B、welcome1234 C、1234 D、1234welcome 解答：C（太难） 3、 Java语言中的一些常用的实用工具，如处理时间的Date类，处理变长数组的Vector类等，所在的包是（）。

A、java.lang包 B、java.io包 C、java.awt包 D、java.util包解答：D

6、在Java中，所有类的根类是（）。 A、java.lang.Object B、java.lang.Class

C、java.applet.Applet D、java.awt.Frame

解答：A

7、以下用于创建容器对象的类是（ A ）

A、 Frame B、 Checkbox C、 Button D、 TextField

8、在JAVA中，以下（ C ）类的对象以键-值的方式存储对象 A、 java.util.List B、 java.util.ArrayList C、 java.util.Hashtable D、 java.util.LinkedList

9、给定如下Java 程序代码片段，编译运行这段代码，结果是（B ）。 java.util.Hashtable table = new java.util.Hashtable(); table .put(\"name\ table .put(\"name\ System.out.println(table .get(\"name\"));

A. null B. Jack C. nullJack D. 运行时出现异常

《Java语言程序设计基础教程》

5.2填空题

1、java的___自动垃圾收集机制大大减轻了程序员的负担，不用再编写专门的内存回收程序解决内存分配问题

2、Math.random()可以产生一个在0和1之间的数，请写出产生一个在125与175之间的整数的语句 Math.round( 125+50*Math.random() )

5.3简答题

1、请举例说明string类与StringBuffer类的区别？

StringBuffer对象的内容可以修改；而String对象一旦产生后就不可以被修改，重新赋值其实是两个对象。StringBuffer的内部实现方式和String不同，StringBuffer在进行字符串处理时，不生成新的对象，在内存使用上要优于String类。所以在实际使用时，如果经常需要对一个字符串进行修改，使用StringBuffer要更加适合一些。

2、写出下面代码的结果，并简单说明原因 public class TestString{

public static void link(String a){ a += \"World\"; }

public static void main(String[] args){ String a = \"Hello\"; link(a);

System.out.println(a); } }

解答：这道题考两个方面:

1). String对象的内容是不能改变的,a+=\"World\"并不是把a所指对象改变，而是先生成一个临时String对象，其值为a+\"World\然后在把这个临时对象赋给a.

2). Java中函数参数传递方式为Call by value,link方法中会生产a的一个拷贝，同样指向a所指的对象，综合以上两点，得出结果为 Hello

5.4综合题

1、请编写程序，将下列字符串s=\"1，2；3，4，5；6，7，8\"转为二维实数数组？

《Java语言程序设计基础教程》

public class ArrayParser{ public static void main(String[] args){ double[][] d; String s=\"1,2;3,4,5;6,7,8\" ; String[] sFirst = s.split(\";\") ; d= new double[sFirst.length][]; for(int i=0 ;i35

《Java语言程序设计基础教程》

第6章图形用户界面设计

6.1单项选择题

1、下列哪一项不是直接或者间接继承了Component类的子类。

A、Frame B、Panel C、Button D、Menu 解答：D

2、下列哪一项是一个用于在GridLayout中的特定区域中放置多个组件的容器？

A、Applet B、Panel C、Button D、Rectangle 解答：B

3、下列容器类中哪一个是从java.awt.Window继承的？（）

A、Frame B、Panel C、Container D、Applet 解答：A

4、下面哪个事件可以处理在文本框中输入回车键的事件______。

A. ItemListener B. ActionListener C. KeyListener D. MouseListener 解答：B

5、Frame类对象的默认布局是什么布局？（）。

A、FlowLayout布局 B、BorderLayout布局 C、CardLayout布局 D、GridLayout布局解答：B

6、Panel类对象的默认布局是什么布局？（）。

A、FlowLayout布局 B、BorderLayout布局 C、CardLayout布局 D、GridLayout布局解答：A

7、下列方法中，不属于WindowListener接口的是(D )。 A．windowOpened()

《Java语言程序设计基础教程》

B．windowClosed() C．windowActivated() D．mouseDragged()

8、JAVA中，容器被重新设置后，哪种布局管理器的容器中的组件大小不随容器大小的变化而改变（B）

（A）CardLayout （B）FlowLayout （C）BorderLayout （D）GridLayout

6.2填空题

1、Java中GUI工具包有__java.awt____和__java.Swing____。 2、通过调用方法__setLayout____可以改变当前容器的布局方式。 3、通过__add____方法向容器中添加组件。

4、AWT布局管理器有______、______、______、______和______。

5、图形用户界面的设计中有事件处理模型处理事件，在该模型中主要包括事件源、事件对象和________事件

6、_______BorderLayout布局管理器包括五个明显的区域：东、南、西、北、中。

6.3简答题

1、请举例简要说明JAVA语言使用事件进行事件处理的过程。

首先事件（包含真正处理事件的代码）向事件源（与事件关联的控件，如按钮、滚动条）注册，事件（敲击键盘，或点击鼠标）发生时，事件源向事件发送一个事件对象（如果在该事件源上注册了多个事件，则向所有的发送）

1）对于某种类型的事件XXXEvent, 要想接收并处理这类事件，必须定义相应的事件类，该类需要实现与该事件相对应的接口XXXListener；

2）事件源实例化以后，必须进行授权，注册该类事件的，使用addXXXListener(XXXListener ) 方法来注册。

2、什么是布局管理器？

解答：Java语言中，提供了布局管理器（LayoutManager）这个工具来管理组件在容器中的布局，如：排列顺序，组件的大小、位置，当窗口移动或调整大小后组件如何变化等，而不使用直接设置组件位置和大小的方式。

每个容器都有一个布局管理器，不同的布局管理器使用不同算法和策略，当容器需要

《Java语言程序设计基础教程》

对某个组件进行定位或判断其大小尺寸时，就会调用其对应的布局管理器。容器可以通过选择不同的布局管理器来决定布局。

3、JAVA的事件处理模型主要涉及到哪3类对象，简单介绍其内容。解答：

事件：用户对界面操作在java语言上的描述，以类的形式出现，例如键盘操作对应的事件类是KeyEvent。

事件源：事件发生的场所，通常就是各个组件，例如按钮Button。事件处理者：接收事件对象并对其进行处理的对象。

4、简述JAVA的组件Component类和容器Container类。

解答：Java的图形用户界面的最基本组成部分是组件（Component），组件是一个以图形化的方式显示在屏幕上并能与用户进行交互的对象，例如一个按钮，一个标签等。组件不能地显示出来，必须将组件放在一定的容器中才可以显示出来。

容器java.awt.Container也是一个类，实际上是Component的子类，因此容器本身也是一个组件，具有组件的所有性质，但是它的主要功能是容纳其它组件和容器。一个容器可以容纳多个组件，并使它们成为一个整体。容器可以简化图形化界面的设计，以整体结构来布置界面。

6.4综合题

1、利用AWT控件编写一个求解一元二次方程根的程序，要求：

（1）具有一元二次方程三个系数a、b、c的输入界面。（2）显示b*b-4*a*c的值。（3）显示求出的根。

2、编写一个应用程序，实现一个基于图形用户界面的加法运算器的功能，窗口中用TextField类来创建三个文本框，用Label类来创建“+”号，用Button类来创建按钮。并通过实现ActionListener接口的，完成如下功能：当用户点击按钮时，对前面两个文本框的数进行相加，并将结果显示在第三个文本框中，如下图所示。

import java.awt.*;

《Java语言程序设计基础教程》

import java.awt.event.* ;

public class TFMath{ public static void main(String[] args){ new TFFrame() ;

}

class TFFrame extends Frame{ TextField num1,num2,num3 ; TFFrame(){ num1=new TextField(10) ; num2=new TextField(10) ; num3=new TextField(15) ; Label lblPlus =new Label(\"+\") ; Button btnEqual =new Button(\"=\");

btnEqual.addActionListener(new MyMonitor()) ; setLayout(new FlowLayout()) ; add(num1); add(lblPlus); add(num2); add(btnEqual); add(num3); pack();

setVisible(true);

}

//private class MyMonitor implements ActionListener{ //类访问它

class MyMonitor implements ActionListener{ public void actionPerformed(ActionEvent e){

int n1 = Integer.parseInt(num1.getText()) ; int n2 = Integer.parseInt(num2.getText()) ; num3.setText(\"\" +(n1+n2)) ; }

}

利于封装，不让别的39

《Java语言程序设计基础教程》

3、编写一个主类为TestGUI的程序实现如下功能：给出一个窗口，带有一个文本框和一个按钮，文本框输入用，用于输入字符。点击按钮后统计字符个数，并输出显示“你输入字符的个数为： ”。

import java.awt.*; import java.awt.event.*;

//import javax.swing.JOptionPane; public class TestGUI extends Frame{

private TextField tf = null; private Button btn = null;

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

public void init() {

//窗口关闭事件

addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent e) { }

System.exit(0);

new TestGUI().init();

});

setLayout(new FlowLayout()); tf = new TextField(15); btn = new Button(\"计算\"); //按键响应事件

btn.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) { }

String s = \"你输入字符的个数为：\" + tf.getText().length(); //JOptionPane.showMessageDialog(null,s); System.out.println(s);

//弹窗显示结果

});

《Java语言程序设计基础教程》

}

add(tf); add(btn);

setBounds(400, 300, 400, 300); //设置窗体的位置和尺寸 setVisible(true);

4、编写一个主类为TestKey的程序实现如下功能：在窗口画出一个红色圆点，并可以通过键盘方向键（左右上下）控制红色圆点圆点进行移动。涉及到KeyEvent对应接口的实现，paint()方法的重写，内部类等知识点。

import java.awt.* ; import java.awt.event.*; import java.util.*;

public class TestKey { }

class KeyFrame extends Frame{

int framLocaX= 200 ; int framLocaY= 200 ;

//Point p = new Point(framLocaX+100, framLocaY+100) ; Point p = new Point(100, 100) ;

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

new KeyFrame().launchFrame() ;

} }

《Java语言程序设计基础教程》

public void launchFrame(){ }

public void paint(Graphics g){ }

class MyKeyMonitor extends KeyAdapter{

public void keyPressed(KeyEvent e){ }

int keyCode = e.getKeyCode() ; /*if(keyCode ==KeyEvent.VK_UP){

System.out.println(\"UP\") ;

}*/

switch (keyCode){ case KeyEvent.VK_UP: }

KeyFrame f= (KeyFrame)e.getSource() ; f.repaint() ;

p.y = p.y-10 ; break;

p.y = p.y+10 ; break;

p.x = p.x+10 ; break;

p.x = p.x-10 ; break;

g.setColor(Color.BLUE); g.fillOval(p.x, p.y, 10, 10); setSize(400,400) ;

setLocation(framLocaX,framLocaY); addKeyListener(new MyKeyMonitor()) ; setVisible(true);

case KeyEvent.VK_DOWN:

case KeyEvent.VK_RIGHT:

case KeyEvent.VK_LEFT:

《Java语言程序设计基础教程》

第7章多线程

7.1单项选择题

1、 Java语言具有许多优点和特点，下列选项中，哪个反映了Java程序并行机制的特点？（）

A、安全性 B、多线程 C、跨平台 D、可移植解答：Ｂ

2、 Runnable接口中的抽象方法是（）。

A、start B、stop C、yield D、run

解答：D

3、有以下程序段 (很难)

class MyThread extends Thread {

public static void main(String args[]) {

MyThread t = new MyThread(); MyThread s = new MyThread(); t.start();

System.out.print(\"one.\"); s.start();

System.out.print(\"two.\"); }

public void run() {

System.out.print(\"Thread\"); } }

则下面正确的选项是（） A、编译失败

B、程序运行结果为：one.Threadtwo.Thread C、程序运行结果是：one.two.ThreaThread D、程序运行结果不确定解答：D

5、作为类中新线程的开始点，线程的执行是从下面哪个方法开始的。（）

《Java语言程序设计基础教程》

A、public void start() B、public void run() C、public void int()

D、public static void main(String args[]) 解答：A

6、Java中用于给对象加“互斥锁”标记的关键字是。（）

A、synchronized B、serialize C、transient D、static 解答：A

7．以下哪个方法用于定义线程的执行体？（ C ） A、 start() B、init() C、run() D、synchronized()

8．以下哪个关键字可以用来为对象加互斥锁？（ D ） A、transient B、static C、 serialize D、synchronized

7.2填空题

7.3简答题

1、多线程有几种实现方法,都是什么?同步有几种实现方法，都是什么?

多线程有两种实现方法，分别是继承Thread类与实现Runnable接口。用Thread类的子类创建线程对象，也就是从Thread类继承。实现Runnable接口，用Thread类直接创建线程对象。

同步的实现方面有两种，分别是synchronized，wait与notify。

2、创建一个新线程的方法，可以使用下面哪2种 ( )

A、继承java.lang.Thread类，并且重载run方法。 B、继承java.lang.Runnable类，并且重载start方法。 C、实现java.lang.thread类，实现run方法。

《Java语言程序设计基础教程》

D、实现java.lang.Runnable接口，实现run方法。 E、实现java.lang.Thread类，实现start方法。解答：A，D

3、线程在它的一个完整的生命周期中有哪4种状态？解答1：

线程在它的一个完整的生命周期中通常要经历如下的4种状态：1. 创建状态(new Thread) 2. 可运行状态( Runnable ) 3. 不可运行状态（Not Runnable）4. 死亡状态（Dead）

解答2：

第一是创建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。

第二是就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态。

第三是运行状态。线程调度程序将处于就绪状态的线程设置为当前线程，此时线程就进入了运行状态，开始运行run函数当中的代码。

第四是阻塞状态。线程正在运行的时候，被暂停，通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep,suspend，wait等方法都可以导致线程阻塞。

第五是死亡状态。如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。对于已经死亡的线程，无法再使用start方法令其进入就绪。

4、线程在什么状态时，调用isAlive()方法返回的值是false。

5、建立线程有哪两种方法？

解答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口。

6、怎样设置线程的优先级？

7、调用Thread类的什么方法可以启动一个线程？直接调用Thread类的run()方法可以启动一个线程吗？

解答：线程调用start()方法将启动线程，从新建状态进入就绪队列排队。不能直接调用Thread类的run()方法可以启动一个线程，我们调用了Thread的run()方法，它的行为就会和普通的方法调用一样。

8、Thread 类中的start() 和 run() 方法有什么区别？

解答：这个问题经常被问到，但还是能从此区分出面试者对Java线程模型的理解程度。start()方法被用来启动新创建的线程，而且start()内部调用了run()方法，这和直接调用run()

《Java语言程序设计基础教程》

方法的效果不一样。当你调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，start()方法才会启动新线程。

9、进程和线程的区别？

解答：进程=执行中的程序，每个进程都有自己的一块内存、一组系统资源。每一个进程的内部数据和状态都是完全的。

线程=进程中单个顺序的流控制，同类的多个线程共享一块内存、一组系统资源。线程的运行开销很小。

一个线程是进程的一个执行流程，一个进程可以同时包含多个线程。

10、现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？

解答：在T2线程的run()方法中加入代码T1.join，在T3线程的run()方法中加入代码T2.join。

或者在主线程main()方法中， t1.start(); try {

t1.join();

} catch (InterruptedException e) {

// TODO Auto-generated catch block e.printStackTrace(); }

t2.start(); try {

t2.join();

} catch (InterruptedException e) {

// TODO Auto-generated catch block e.printStackTrace(); }

t3.start();

11、Thread.start()与Thread.run()有什么区别？

解答：通过调用Thead类的start()方法来启动一个线程，使之进入就绪状态，当cpu分配时间该线程时，由JVM调度执行run()方法。直接使用run()方法叫做方法调用，不能启动线程。

12、在一个对象上两个线程可以调用两个不同的同步实例方法吗？

解答：不能，因为一个对象已经同步了实例方法，线程获取了对象的对象锁。所以只有执行完该方法释放对象锁后才能执行其它同步方法。

《Java语言程序设计基础教程》

13、当一个同步方法已经执行，线程能够调用对象上的非同步实例方法吗？

解答：可以，一个非同步方法总是可以被调用而不会有任何问题。实际上，Java没有为非同步方法做任何检查，锁对象仅仅在同步方法或者同步代码块中检查。如果一个方法没有声明为同步，即使你在使用共享数据Java照样会调用，而不会做检查是否安全，所以在这种情况下要特别小心。一个方法是否声明为同步取决于临界区访问(critial section access),如果方法不访问临界区(共享资源或者数据结构)就没必要声明为同步的。

14、wait方法的作用？

解答：wait方法用在 synchronized 方法或者 synchronized块中。一般在判断语句中，如果某条件被触发，让当前线程wait并释放对象的锁。此时可以让其他线程可以对用以对象调用synchronized方法。直到调用 notify或者notifyAll后 wait的线程才有可能执行。所以一般wait 和 notify是成对出现的。

15、启动一个线程是用run()还是start()，调用的时候有什么区别？（同第8题）

解答：当然是start()了，当调用线程的start()方法的时候，线程就会进入到就绪状态。run()方法是线程的执行入口，当线程从就绪状态进入到执行状态时首先要从run()方法开始执行。

当然，我们也是可以直接通过线程对象调用该对象的run()方法的，只是这只是一次普通的调用，并没有启动任何一个线程。

当我们调用start()方法时，是另外启动了一个线程去执行线程类的代码，并不影响主程序的执行，但是调用run()方法的时候要等待run()方法内的代码执行完主程序才可以向下执行

16、 sleep() 和 wait() 有什么区别？

解答：sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

7.4综合题

14、编写一个死锁程序？

15、在下面的代码区填入相应的代码，实现以下功能：

通过继承Thread类的子类Thread1，来创建和启动一个线程t1；

《Java语言程序设计基础教程》

通过实现Runnable接口的具体类Runner1，来创建和启动一个线程t2； public class TestThread1{ public static void main(String[] args){

//创建和启动一个线程t1，在下面写出相应代码 Thread1 t1 =new Thread1 () ; t1.start() ;

//创建和启动一个线程t2，在下面写出相应代码 Runner1 r1 =new Runner1() ; Thread t2 =new Thread(r1) ; t2.start() ; for(int i=0;i<100;i++){ System.out.println(\"Main Thread:......\"+i) ; } } }

class Runner1 implements Runnable{ public void run(){ for(int i=0;i<100;i++){ System.out.println(\"Runner1:......\"+i) ; } } }

class Thread1 extends Thread{ public void run(){ for(int i=0;i<100;i++){ System.out.println(\"Thread1:......\"+i) ; } } }

16、现在有T1 T2 T3三个线程，怎样保证T2在T1执行完之后执行 T3在T2执行完之后执行。请在相应区域写出实现该功能的代码。

public class JoinDemo {

public static void main(String[] args) { T1 t1=new T1(\"T1\");

《Java语言程序设计基础教程》

T2 t2=new T2(\"T2\"); T3 t3=new T3(\"T3\"); t1.start(); try {

t1.join();

} catch (InterruptedException e) {

// TODO Auto-generated catch block e.printStackTrace(); }

t2.start(); try {

t2.join();

} catch (InterruptedException e) {

// TODO Auto-generated catch block e.printStackTrace(); }

t3.start(); } }

class T1 extends Thread{ private String name; public T1(String name) { this.name=name; }

public void run() {

for(int i=0;i<5;i++){ try {

sleep(5);

} catch (InterruptedException e) {

// TODO Auto-generated catch block e.printStackTrace(); }

System.out.println(this.name+\"循环\"+i); } } }

class T2 extends Thread{ private String name;

《Java语言程序设计基础教程》

public T2(String name) { this.name=name; }

public void run() {

for(int i=0;i<5;i++){ try {

sleep(5);

} catch (InterruptedException e) {

// TODO Auto-generated catch block e.printStackTrace(); }

System.out.println(this.name+\"循环\"+i); } } }

class T3 extends Thread{ private String name; public T3(String name) { this.name=name; }

public void run() {

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

System.out.println(this.name+\"循环\"+i); } } }

第8章文件和流

8.1单项选择题

1、创建一个向文件“file.txt”追加内容的输出流对象的语句是（ A. OutputStream out=new FileOutputStream(“file.txt”);

B. OutputStream out=new FileOutputStream(“file.txt”, “append”); C. FileOutputStream out=new FileOutputStream(“file.txt”, true); D. FileOutputStream out=new FileOutputStream(new file(“file.txt”)); 50

。）

《Java语言程序设计基础教程》

解答：C

2、下面哪个流类属于面向字符的输入流( )

A BufferedWriter B FileInputStream C ObjectInputStream D InputStreamReader 答案：D

3、以下关于File 类说法错误的是（D）

A．一个File 对象代表了操作系统中的一个文件或者文件夹 B．可以使用File 对象创建和删除一个文件 C．可以使用File 对象创建和删除一个文件夹

D．当一个File 对象被垃圾回收时，系统上对应的文件或文件夹也被删除

4、为了提高读写性能，可以采用什么流？（ D） A InputStream B DataInputStream C OutputStream

D BufferedInputStream

5、File类型中定义了什么方法来判断一个文件是否存在？（ D） A createNewFile B renameTo C delete D exists

6、File类型中定义了什么方法来创建多级目录？（ C） A createNewFile B exists C mkdirs D mkdir 7、（Buffered 流，缓冲区）有下面代码 import java.io.*;

public class TestBufferedWriter{

public static void main(String args[]) throws Exception{ FileWriter fw = new FileWriter(“test.txt”); BufferedWriter bw = new BufferedWriter(fw); String str = “Hello World”; bw.write(str); } }

在处放入什么代码，能够使得test.txt 文件被正确写入？

《Java语言程序设计基础教程》

A. bw.close() B. bw.flush(); C. fw.close();

8.2填空题

1、对于FileInputStream 来说，从方向上来分，它是____输入_____流，从数据单位上分，它是___字节___流。

2、创建FileOutputStream 对象时，如果对应的文件在硬盘上不存在，则会_自动创建___；如果对应的文件在硬盘上已经存在，则__覆盖______

8.3简答题

1、java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？

解答：

字节输入流：InputStream,字节输出流：OutputStream 字符输入流：Reader，字符输出流：Writer

2、什么是java序列化，如何实现java序列化？

解答：Java对象的序列化指将一个java对象写入OI流中，与此对应的是，对象的反序列化则从IO流中恢复该java对象。

如果要让某个对象支持序列化机制，则必须让它的类是可序列化的，为了让某个类是可序列化的，该类必须实现Serializable接口或Externalizable接口。

8.4综合题

3、 FileInputStream流的read方法和FileRead流的read方法有何不同？ 4、 BufferedReader流能直接指向一个文件对象吗？ 1、（FileInputStream 和FileOutputStream）利用FileInputStream 和FileOutputStream，完成下面的要求：

1）用FileOutputStream 在当前目录下创建一个文件“test.txt”，并向文件输出“Hello

《Java语言程序设计基础教程》

World”，如果文件已存在，则在原有文件内容后面追加。

2）用FileInputStream 读入test.txt 文件，并在控制台上打印出test.txt 中的内容。 3）要求用try-catch-finally 处理异常，并且关闭流应放在finally 块中。 FileInputStream fin; FileOutputStream fon; try{

fin = new FileInputStream(\"hello.txt\"); on = new FileOutputStream(\"test.txt\ fon.write(“Hello World”);

System.out.println( fin.read() ); fin.close();

}catch(Exception e){}finally{fin.close();}

1、使用FileInputStream类，编写一个程序，顺序读取d:/text.txt的文件里的内容，并显示在控制台上面，直到文件结束为止。？

import java.io.FileInputStream;

import java.io.FileNotFoundException; import java.io.IOException;

public class ep8_2 { public static void main(String[] args) { FileInputStream fis; try { fis = new FileInputStream(\"text.txt\"); System.out.print(\"content of text is : \"); int b; while ((b = fis.read()) != -1) // 顺序读取文件text里的内容 { System.out.print((char) b); } fis.close(); } catch (FileNotFoundException e) { System.out.println(e); } catch (IOException e) { System.out.println(e); } } }

2、使用FileInputStream类和FileOutputStream类，编写一个程序，顺序读取d:/text.txt

《Java语言程序设计基础教程》

的文件里的内容，并将内容拷贝到d:/text.bak文件？

import java.io.*;

public class TestFileOutputStream{ public static void main(String[] args){ int b = 0 ; FileInputStream in =null ; FileOutputStream out = null; try{ in = new FileInputStream(\"d:/text.txt\") ; out = new FileOutputStream(\"d:/text.bak\"); while((b=in.read())!=-1){ out.write(b); } in.close(); out.close(); }catch(FileNotFoundException e2){ System.out.println(\"找不到文件\") ; System.exit(-1); }catch(IOException e1){ System.out.println(\"文件复制错误\") ; System.exit(-1); } System.out.println(\"文件已经复制\") ; } }

3、递归列出d:/java目录下的所有子目录和文件，再显示到控制台 import java.io.* ;

public class FileList{ public static void main(String[] args){ File f = new File(\"d:/java\") ; System.out.println(f.getName()) ; tree(f,1) ; } private static void tree(File f, int level){ String preStr = \"\" ; for(int i=0;i54

《Java语言程序设计基础教程》

} File[] childs = f.listFiles() ; for(int i=0 ;i4、首先列出当前工作目录，然后将当前目录下面的所有文件取出，根据过滤器设置，显示后缀为java的所有文件。

import java.io.*; //引入java.io包中所有的类

public class ep8_1 { public static void main(String args[]) { File dir = new File(\"c://java_work//8\"); // 用File 对象表示一个目录 Filter filter = new Filter(\"java\"); // 生成一个名为java的过滤器 System.out.println(\"list java files in directory \" + dir); String files[] = dir.list(filter); // 列出目录dir下，文件后缀名为java的所有文件 for (int i = 0; i < files.length; i++) { File f = new File(dir, files[i]); // 为目录dir 下的文件或目录创建一个File 对象

if (f.isFile()) // 如果该对象为后缀为java的文件，则打印文件名 System.out.println(\"file \" + f); else System.out.println(\"sub directory \" + f); // 如果是目录则打印目录名 } } }

class Filter implements FilenameFilter { String extent; Filter(String extent) { this.extent = extent; }

《Java语言程序设计基础教程》

public boolean accept(File dir, String name) { return name.endsWith(\".\" + extent); // 返回文件的后缀名 } }

5、请编写一个程序，开启一个文本文件，一次读取其内的一行文本，令每行形成一个String，并将读出的String对象置于LinkedList中，以反相次序显示出LinkedList内的所有内容。

import java.io.*; import java.util.*; class exA4_2{

public static void main(String args[]) throws Exception{ LinkedList lines=new LinkedList(); BufferedReader in=

new BufferedReader(new FileReader(\"exA4_2.java\")); String s;

while((s=in.readLine())!=null) lines.add(s); in.close();

ListIterator it=lines.listIterator(lines.size()); while(it.hasPrevious())

System.out.println(it.previous()); } }

6、在程序中写一个\"HelloJavaWorld你好世界\"输出到操作系统文件Hello.txt文件中 import java.io.File;

import java.io.FileOutputStream;

public class Test5 { /** * 在程序中写一个\"HelloJavaWorld你好世界\"输出到操作系统文件Hello.txt文件中

* * 程序分析：文件写入，要用到输出流FileOutputStream * */ public static void main(String[] args) { // 向文件D:/Hello.txt，写入内容

《Java语言程序设计基础教程》

File file = new File(\"D:/Hello.txt\"); try { // 创建输出流 FileOutputStream fos = new FileOutputStream(file); //把String类型的字符串转化为byte数组的数据保存在输出流中 fos.write(\"HelloJavaWorld你好世界\".getBytes()); fos.flush();//刷新输出流 fos.close();//关闭输出流 } catch (Exception e) { e.printStackTrace(); } } }

7、统计一个文件calcCharNum.txt（见附件）中字母'A'和'a'出现的总次数import java.io.File;

import java.io.FileInputStream;

public class Test7 { /** * 统计一个文件calcCharNum.txt（见附件）中字母'A'和'a'出现的总次数 * * 程序分析： * 读取文件用FileInputStream * 一次只读一个字节(一个字母就是一个字节)，当字节内容和A或a相等时，相应的数量加1

* */ public static void main(String[] args) { try { //添加文件路径 File file = new File(\"D:/java/calcCharNum.txt\"); //创建文件读取流 FileInputStream fis = new FileInputStream(file); int numA = 0;//字母A的数量 int numa = 0;//字母a的数量 int len = 0;//每次读取的字节数量 while ((len=fis.read())!= -1) { //统计字母a的数量 if (new String((char)len+\"\").equals(\"a\")) {

《Java语言程序设计基础教程》

numa++; } //统计字母A的数量 if (new String((char)len+\"\").equals(\"A\")) { numA++; } } //打印出文件内字母的数量 System.out.println(\"a的数量是：\"+numa); System.out.println(\"A的数量是：\"+numA); System.out.println(\"a和A出现的总次数：\"+(numA+numa)); fis.close();//关闭输入流 } catch (Exception e) { e.printStackTrace(); } } }

8、输入两个文件夹名称，将A文件夹内容全部拷贝到B文件夹，要求使用多线程来操作。

import java.io.File;

import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.util.List; import java.util.Scanner;

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors;

import com.xykj.lesson2.FileUtils;

public class Test12 { /* * 输入两个文件夹名称，将A文件夹内容全部拷贝到B文件夹，要求使用多线程来操作。

《Java语言程序设计基础教程》

* 程序分析： * 1.拷贝文件里面的东西，要分析的东西还是蛮多的，要先建文件夹再拷贝里面的东西，而且要一层层的来搞

* 2.这里也需要文件遍历工具，直接调用第二题的工具类，不再重写 * 3.多线程的使用，可以直接在方法里面直接新建线程 * 4.对整个文件夹进行复制文件夹分隔符可以用\\\\或/，其他的都是不对的 * 所有其中还对输入的分割符进行了替换 * 这题看起来比较长，分开看其实也不长 * */ public static void main(String[] args) { Scanner scanner=new Scanner(System.in); System.out.println(\"要复制的文件夹：\"); String fromDir = scanner.next();// 接收输入 System.out.println(\"要复制到哪里去：\"); String toDir = scanner.next();// 接收输入 // 把输入的地址转化为File类型 File fromFile = new File(fromDir); File toFile = new File(toDir); //新建线程 new Thread(){ //里面做实际操作 public void run() { // 判断如果要复制的是文件，直接复制就可以了 if (fromFile.isFile()) { System.out.println(\"复制单个文件\"); copy(fromFile, toFile); } else { // 要复制文件夹 // 要防止一种无法进行的复制：比如说，要把复制的文件复制到自己的子文件夹里面

// 举个例子：把D:/java/jsp文件夹复制到D:/java/jsp/js文件夹里面，

// 这会导致子文件不断增加的同时，而父文件也要不断增加，的一个死循环

// 如果反过来，就没事，相当于只是简单的覆盖而已 // 具体实现就是看：目的地地址包含复制的文件夹地址，就不允许操作

\"/\");

《Java语言程序设计基础教程》

if (toDir.replace(\"/\ .startsWith(fromDir.replace(\"/\ return; }

// 复制文件（包括文件和文件夹）操作 // 先获取所有的文件（包括文件和文件夹） List list = FileUtils.getAllFiles(fromDir);

// 创建一个线程池，加快复制的速度

ExecutorService threadPool = Executors.newFixedThreadPool(20); // 需要对每一个文件的路径进行处理 for (File file : list) { // 复制文件名 String name = file.getAbsolutePath(); // 把原来的文件路径换成新的文件路径 String toName = name.replace(fromFile.getParent(), toDir + System.out.println(name + \"变成了\" + toName); // 如果是文件夹，直接创建 if (file.isDirectory()) { new File(toName).mkdirs(); } else { // 如果是文件,在线程里面复制 threadPool.execute(new Runnable() { @Override public void run() { File copyFile = new File(toName); // 先要有父文件夹 copyFile.getParentFile().mkdirs(); // 开始复制文件 copy(file, copyFile);

} });

}

《Java语言程序设计基础教程》

} scanner.close(); }; }.start();//开始线程 }

//复制文件的操作

public static void copy(File fromFile, File toFile) { // 定义一个输入流 FileInputStream fis = null; // 定义一个输出流 FileOutputStream fos = null; try { // 把复制地址的File，封装后赋值给输入流对象 fis = new FileInputStream(fromFile); // 把目的地的File，封装后复制给输出流的对象 fos = new FileOutputStream(toFile); // 创建一个容量， byte[] buf = new byte[1024]; // 每次读取/写入的字节长度 int len = 0; // 边读边写 while ((len = fis.read(buf)) != -1) {// 判断是否还能读到数据 // 把输入放到输出流里面 fos.write(buf, 0, len); }

} catch (Exception e) { e.printStackTrace(); } finally { try { // 关闭输入流和输出流 fis.close(); fos.close(); } catch (IOException e) { e.printStackTrace();

}

《Java语言程序设计基础教程》

}

第9章异常处理

9.1单项选择题

1、为了捕获一个异常，代码必须放在下面（）语句块中。

A、try块 B、catch块 C、throws块 D、finally块解答：A

3、下列常见的系统定义的异常中，哪个是输入、输出异常?（）

A、ClassNotFoundException B、IOException

C、FileNotFoundException D、UnknownHostException 解答：Ｂ

4、在代码中，使用catch(Exception e)的好处是 ( )

A、只会捕获个别类型的异常

B、捕获try块中产生的所有类型的异常 C、忽略一些异常 D、执行一些程序解答：B（太难）

6、异常包含下列那一个内容？（）

A、程序中的语法错误 B、程序的编译错误

C、程序执行过程中遇到的事先没有预料到的情况 D、程序事先定义好的可能出现的意外情况解答：C（太难）

7、getCustomerInfo()方法如下，try中可以捕获三种类型的异常，如果在该方法运行中产生了一个IOException，将会输出什么结果（A）

public void getCustomerInfo() {

《Java语言程序设计基础教程》

try {

// do something that may cause an Exception } catch (java.io.FileNotFoundException ex) {

System.out.print(\"FileNotFoundException!\"); } catch (java.io.IOException ex) {

System.out.print(\"IOException!\"); } catch (java.lang.Exception ex) { System.out.print(\"Exception!\"); } }

A IOException!

B IOException!Exception!

C FileNotFoundException!IOException!

D FileNotFoundException!IOException!Exception!

8、有如下代码段: 1)

2) { if(unsafe()){//do something…} 3) else if(safe()){//do the other…} 4) }

其中，方法unsafe() 将抛出IOException, 请问可将以下哪项填入第1行？（ D ） A、 public IOException methodName() B、 public void methodName()

C、public void methodName() throw IOException D、public void methodName() throws IOException

9、java中用来抛出异常的关键字是 (C) A、try B、catch C、throw D、finally

10、java中关于异常，下列说法正确的是 (A)

A、异常是一种对象 B、一旦程序运行，异常将被创建

C、为了保证程序运行速度，要尽量避免异常控制 D、以上说法都不对 11、（A）类是所有异常类的父类。

A、Throwable B、Error C、Exception D、AWTError

12、对于catch子句的排列，下列哪种是正确的(B ) A、父类在先，子类在后 B、子类在先，父类在后

C、有继承关系的异常不能在同一个try程序段内

《Java语言程序设计基础教程》

D、先有子类，其他如何排列都无关

13、在异常处理中，如释放资源、关闭文件、关闭数据库等由(C )来完成。 A、try子句 B、catch子句 C、finally子句 D、throw子句

14、当方法遇到异常又不知如何处理时，下列哪种说法是正确的(C ) A、捕获异常 B、抛出异常 C、声明抛出异常 D、嵌套异常

15、一个异常将终止( A)

A、整个程序 B、只终止抛出异常的方法 C、产生异常的try块 D、上面的说法都不对

9.2填空题

1、系统定义的运行异常都可以由系统自动抛出，而用户定义的异常应使用_____ throw_____ 语句抛出。

2、_____Throwable______类是Java异常类的根类。

3、抛出自定义异常用throws____语句，在方法中抛出异常采用__throw__ 语句。

4、异常____就是在程序的运行过程中所发生的错误

5、捕获异常的统一出口通过___finally______语句实现

6、java语言的类库中提供了一个___Throwable_______类，所有的异常都必须是它的实例或它子类的实例

7、Exception包括______运行时异常和______非运行时异常。

8、catch子句都带一个参数，该参数是某个异常的类及其变量名，指明它所能够捕获的异常类型。catch用该参数去与 __异常_____对象的类进行匹配。

9、Java语言中有两种异常处理机制：捕获异常和声明抛弃异常。

《Java语言程序设计基础教程》

9.3简答题

9、什么是Error异常类，什么是Exception异常类，两者在处理上有什么区别?

解答：Java中的异常类可分为两大类： Error和Exception。Error包括动态链接失败，虚拟机错误等，通常Java程序不应该捕获这类异常，也不会抛弃这种异常。 Exception包括运行时异常和非运行时异常。

Error(错误)表示系统级的错误和程序不必处理的异常，是java运行环境中的内部错误或者硬件问题，比如，内存资源不足等，对于这种错误，程序基本为力，除了退出运行外别无选择。

Exception(违例)表示需要捕捉或者需要程序进行处理的异常，它处理的是因为程序设计的瑕疵而引起的问题或者外部环境造成的异常，是程序必须处理的。

2、 Exception异常类包括运行时异常和非运行时异常，简单介绍两者内容。

解答：继承于RuntimeException的类都属于运行时异常，例如算术异常（除零错）、数组下标越界异常等等。由于这些异常产生的位置是未知的，Java 编译器允许程序员在程序中不对它们做出处理。

除了运行时异常之外的其他由Exception 继承来的异常类都是非运行时的异常，例如FileNotFoundException（文件未找到异常）。Java编译器要求在程序中必须处理这种异常，捕获异常或者声明抛弃异常。

3、Java语言中有哪两种异常处理机制，简单进行介绍。解答：捕获异常和声明抛弃异常。

（1）捕获异常：当Java运行环境得到一个异常对象时，它将会沿着方法的调用栈逐层回溯，寻找处理这一异常的代码。找到能够处理这种类型的异常的方法后，运行环境把当前异常对象交给这个方法进行处理，这一过程称为捕获（catch）异常。这是积极的异常处理机制。如果Java运行环境找不到可以捕获异常的方法，则运行环境将终止，相应的Java程序也将退出。

（2）声明抛弃异常：如果一个方法并不知道如何处理所出现的异常，则可在方法声明时，声明抛弃（throws）异常。这是一种消极的异常处理机制。

9.4综合题

7、编写一个异常类MyException，再编写一个类Student，该类有一个产生异常的方法public void speak(int m) throws MyException，要求参数m的值大于1000时，方法抛出一个MyException对象。最后编写主类，在主类的main方法中用Student创建一个对象，让

该对象调用speak方法。

（我写的简单方法）

《Java语言程序设计基础教程》

public class TestException1 { }

class Student{ }

class MyException extends Exception{

public MyException(){ } }

super() ;

public void speak(int m) throws MyException{ }

if(m>1000){ }

MyException e = new MyException() ; throw e ;

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

// TODO Auto-generated method stub Student st1 = new Student() ; try{ }

st1.speak(10);

System.out.println(\"param m out of 1000\") ; }catch(MyException e){

*********************************************************** ***********************************************************

（标准答案）

import java.util.Scanner;

class MyException extends Exception {

String message;

《Java语言程序设计基础教程》

MyException(int m) { message = \"the number \" + m + \" great than 1000\";

}

public String toString() { return message;

}

class Student { public void speak(int m) throws MyException { if(m > 1000) { MyException ex = new MyException(m); throw ex;

} else { System.out.println(\"the number is: \" + m); }

}

};

class TestException1{ public static void main(String args[]) { Student s = new Student(); try { //System.out.print(\"Please input number: \"); //Scanner num = new Scanner(System.in); s.speak(10000);

}catch(MyException mye)

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

}

};

《Java语言程序设计基础教程》

1．参考下面的程序，试修改程序，捕获相关异常，使得程序能正常运行。[提示：用错误数据测试，即可得到异常类名，运行时主方法参数输入 abc 测试] public class StringIndexOutOf {

public static void main(String args[]) { System.out.println(\"字符串索引越界异常\"); String str=args[0];

System.out.println(“第四个字符为 ”+str.charAt(3));

int aa=Integer.parseInt(args[0]); System.out.println(“平方为 ”+aa*aa); } } 2．从命令行得到5个整数，放入一整型数组，然后打印输出，要求：如果输入数据丌为整数，要捕获Integer.parseInt()产生的异常，显示“请输入整数”，捕获输入参数丌足5个的异常(数组越界)，显示“请输入至少5个整数”。

3．写一个方法void sanjiao(int a,int b,int c)，判断三个参数是否能构成一个三角形，如果丌能则抛出异常IllegalArgumentException，显示异常信息a,b,c+”丌能构成三角形”，如果可以构成则显示三角形三个边长。

4．自定义类Sanj，其中有成员 x,y,z,作为三边长，构造方法Sanj(a,b,c)分别给x,y,z 赋值,方法求面积getArea和显示三角形信息(三个边长)showInfo，这2个方法中当三条边丌能构成一个三角形时要抛出自定义异常NotSanjiaoException，否则显示正确信息。在另外一个类中的主方法中构造一个Sanj对象(三边为命令行输入的三个整数)，显示三角形信息和面积，要求捕获异常。

因篇幅问题不能全部显示，请点此查看更多更全内容

查看全文