（部选）JAVA各章习题及答案

面向对象程序设计-java语言习题答案 第一章 一、选择题

1．下列选项中，不属于Java语言特点的一项是（ C ）。

（A）分布式

（B）安全性 （C）编译执行

（D）面向对象

【解析】Java程序采用解释执行的方法。在系统编译运行Java程序时，Java编译器将Java程序转化为字节码，在运行时，解释器将编译得到的字节码进行解释执行。 2．在Java语言中，（ C ）是最基本的元素？

（A）方法

（B）包 （C）对象

（D）接口

）？

【解析】构成Java程序的基本元素类（抽象的对象）。

3．编译一个定义了3个类和10个方法的Java源文件后，会产生（ D ）个字节码文件？扩展名是（ D

（A）13个字节码文件，扩展名为.class （C）3个字节码文件，扩展名为.java 5．Java语言属于（ B ）种语言？

（A）面向机器的语言（B）面向对象的语言（C）面向过程的语言（D）面向操作系统的语言 【解析】Java语言是一种纯面向对象的语言。

6．下列关于Application和Applet程序的说法中不正确的一项是（ B ）。

（A）Application使用解释器java.exe （B）Application不使用独立的解释器 （C）Applet在浏览器中运行

（D）Applet必须继承Java的Applet类

【解析】Application程序包含main()方法，它是一种独立执行的程序，因此必须使用独立的解释器解释执行。 7．下列选项中，不属于Java核心包的一项是（ A ）。

（A）javax.swing

（B）java.io （C）java.utile（D）java.lang

【解析】凡是以java开头的包都是Java核心包，以javax开头的包则属于Java扩展包。 8．下列描述中，不正确的是（ A ）。

（A）Java不支持多线程

（B）一个Java源文件不允许有多个公共类 （D）Java程序分为Application和Applet两类

（C）Java通过接口支持多重继承 【解析】Java是支持多线程的语言。

9．阅读下列代码，选出该代码段正确的文件名（ C ）。

class A{ }

public class B{ }

（A）A.java

（B）A.class （C）B.java （D）B.class

【解析】Java源文件名必须和公共类的名字完全一样，源文件的扩展名为.java。 10．编译下面源程序会得到哪些文件（ D ）？

class A1{ } 1

void method2(){ }

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

System.out.println(\System.out.println(\void method1(){ }

System.out.println(\

（B）1个字节码文件，扩展名为.class （D）3个字节码文件，扩展名为.class

【解析】源文件中的每一个类编译后都会生成一个字节码文件，字节码文件的扩展名是.class。

class A2{ }

public class B{ }

（A）只有B.class文件（B）只有A1.class和A2.class文件（C）编译不成功（D）A1.class、A2.class和B.class文件

【解析】由于该程序包含3个类，每个类编译后都会生成1个字节码文件，因此编译后会生成以这3个类名命名的字节码文件。 二、填空题

1．Java程序的编译和执行模式包括2点，是 半编译 和 半解释 。

2．Java语言支持 TCP/IP 协议，从而使得Java程序在分布式环境中能够很方便地访问处于不同地点的 对象 。 3．开发Java程序的一般步骤是：源程序编辑、 生成字节码 和 解释执行 。

4．每个Java Application程序可以包括许多方法，但是必须有且只能有一个 main() 方法，统一格式为 public static void main(String[] args) ，它是程序执行的入口。

5．JVM把字节码程序与各种不同的 操作系统 和 硬件 分开，使得Java程序独立于平台。 7．Java源程序文件和字节码文件的扩展名分别为 .java 和 .class 。

8．如果在Java程序中需要使用java.utile包中的所有类，则应该在程序开始处加上 import java.utitle.* 语句。 三、编程题

1．编写一个Java Application类型的程序，输出“This is my first Java Application！”。

【编程分析】 要编写Java Application类型的程序，需要在Exclipse中创建一个Java Application类型的工程，这时Exclipse会自动创建程序框架，该框架包含一个公共类，其中包含一个main()方法。删除main()方法中自动生成的代码，编写自己的代码即可。由于该程序要求输出一句话，因此在main()方法中直接调用System.out.println()或System.out.print()方法即可实现。 【参考程序】

public class X3_1 { }

【运行结果】

This is my first Java Application! 第2章 一、选择题

1．下列（ D ）是合法的标识符？

（A）12class

（B）void

（C）-5

（D）_blank

【解析】根据Java标识符的构成规则确定。 2．下列（ B ）不是Java中的保留字？

（A）if

（B）sizeof

（C）private

（D）null

【解析】根据Java保留字表进行选择。 3．下列（ C ）不是合法的标识符？

（A）$million

（B）$_million

（C）2$_million

（D）$2_million

【解析】根据Java标识符的构成规则确定。

4．下列选项中，（ B ）不属于Java语言的基本数据类型？

（A）整数型

（B）数组

（C）浮点型

（D）字符型

【解析】根据Java语言的基本数据类型包含的类别选取。 5．下列关于基本数据类型的说法中，不正确的一项是（ D ）。

（A）boolean类型变量的值只能取真或假B）float是带符号的32位浮点数C）double是带符号的64位浮点数D）char是8位Unicode2

public static void main(String args[]){

System.out.println(\

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

}

字符

【解析】Java中的字符采用的是16位的Unicode字符。

6．下列关于基本数据类型的取值范围的描述中，正确的一个是（ B ）。

（A）byte类型的取值范围是-128～128 （B）boolean类型的取值范围是真或假 （C）char类型的取值范围是0～65536 127，其他类型也是如此。

7．下列关于Java语言简单数据类型的说法中，正确的一项是（ A ）。

（A）以0开头的整数代表8进制整型常量 （B）以0x或0X开头的整数代表8进制整型常量

（C）boolean类型的数据作为类成员变量的时候，相同默认的初始值为true （D）double类型的数据占计算机存储的32位 【解析】根据每种数据类型的特性进行判断。 8．下列Java语句中，不正确的一项是（ C ）。

（A）int e, a, b = 10;（B）char c, d = ?a‘;（C）float e = 0.0d; （D）double c = 0.0f; 【解析】不能将double类型的常量赋值给float类型的变量。

9．在编写Java程序时，如果不为类的成员变量定义初始值，Java会给出它们的默认值，下列说法中不正确的一个是（ D ）。

（A）byte的默认值是0 （B）boolean的默认值是false （C）char类型的默认值是‘\\0‘ （D）long类型的默认值是0.0L 【解析】long类型的默认值是0L，而不是0.0L。 10．下列语句中不正确的一个是（ B ）。

（A）float f = 1.1f; （B）byte b = 128; （C）double d = 1.1/0.0; （D）char c = (char)1.1f; 【解析】bytel类型变量的取值范围是-128～127。 11．下列表达式1+2+ \的值是（ B ）。

（A）\

（B）\

（C）\

（D）\

【解析】整数和整数相加得到两个整数的和，而整数和字符串相加得到的是字符串。 12．已知y=2, z=3, n=4，则经过n=n+ -y*z/n运算后n的值为（ A ）。

（A）3

（B）-1

（C）-12

（D）-3

【解析】根据运算符的优先级，该表达式相当于n=n+ ((-y)*z)/n。 13．已知a=2, b=3，则表达式a%b*4%b的值为（ A ）。

（A）2

（B）1

（C）-1

（D）-2

【解析】根据运算符的优先级，该表达式相当于((a%b)*4)%b。 14．已知x=2, y=3, z=4，则经过z- = --y – x--运算后，z的值为（ D ）。

（A）1

（B）2

（C）3

（D）4

【解析】在表达式运算过程中，--y的值变为2，x—的值还是2，等号右侧运算后的值为0，因此z的值没有变化。 15．表达式(12==0) && (1/0 < 1)的值为（ B ）。

（A）true

（B）false

（C）0

（D）运行时抛出异常

【解析】由于(12==0)的值为false，因此整个表达式发生短路运算，即(1/0 < 1)就没有参与运算，整个表达式的值为false。 16．设有类型定义short i=32; long j=64; 下面赋值语句中不正确的一个是（ B ）

（A）j=i;

（B）i=j;

（C）i=(short)j;

（D）j=(long)i;

【解析】long类型的数据不能自动转变为short类型，因此不能将long类型的变量直接赋值给short类型。 17．现有1个char类型的变量c1=66和1个整型变量i=2，当执行c1=c1+(char)i;语句后，c1的值为（ D ）。

（A）'d'

（B）'D'

（C）68

（D）语句在编译时出错

【解析】两个字符型的数据相加，得到的是一个整数，而如果把整数再赋值给一个字符型变量则会在编译时出错。 18．下列说法中，正确的一项是（ D ）。

（A）字符串\的长度为6 （B）False是Java的保留字 （C）123.45L代表单精度浮点型 （D）False是合法的Java标识符

【解析】Java语言对字符的大小写是敏感的，False不是false，因此False是合法的Java标识符。 19．以下的变量定义语句中，合法的是（ D ）

（A）float _*5 = 123.456F; （B）byte $_b1 = 12345; （C）int _long_ = 123456L; （D）double d = Double.MAX_VALUE; 3

（D）short类型的取值范围是-32767～32767

【解析】根据每种类型占几个字节即可推算出其取值范围，如byte类型占1个字节，即共包含28个数值，其取值范围范围应为-128～

【解析】（A）中_*5不是合法的标识符，（B）中12345超出byte范围，（C）中不能将long类型的常量赋值给int型的变量。 20．下列关于运算符优先级的说法中，不正确的一个是（ C ）

（A）运算符按照优先级顺序表进行运算 （B）同一优先级的运算符在表达式中都是按照从左到右的顺序进行运算的 （C）同一优先级的运算符在表达式中都是按照从右到左的顺序进行运算的 （D）括号可以改变运算的优先次序 【解析】同一优先级的运算符在表达式中都是按照从左到右的顺序进行运算的。 二、填空题

1．变量是Java程序的基本存储单元之一，变量的主要类型包括2大类：字符型 和 数值型 。

2．Java语言的整数类型变量和常量一样，各自都包括4种类型的数据，它们分别是byte、 int 、 short 和long。 3． boolean 类型数据不可以做类型转换。

4．在Java语言的基本数据类型中，占存储空间最少的类型是 boolean ，该类型占用的存储空间为 1 位。 5．Java语言中的 保留字 具有特殊意义和作用，不能作为普通标识符使用。 6．在Java语言中，浮点类型数据属于实型数据，可以分为 单精度 和 双精度 两种。 7．char类型的数据可以表示的字符数共为 65536 。

8．定义初始值为10的8次方的常整型变量iLong的语句是 final iLong = 100000000L 。 9．Java语言中的数据类型转换包括 自动转换 和 强制转换 两种。 10．Java中的字符采用的是16位的 Unicode 编码。

11．数据类型中存储空间均为64位的两种数据类型是 long 和 double 。 12．表达式9*4/ -5%5的值为 -2 。（十进制表示） 17．表达式10^2的值为 8 。（十进制表示）

19．若a、b为int型变量，并且已分别赋值为5和10，则表达式(a++)+(++b)+a*b的值为 82 。 20．假设i=10, j=20, k=30，则表达式 !(i

3．编写一个Java Application类型的程序，从键盘上输入三角形的三条边的长度，计算三角形的面积和周长并输出。根据三角形边长求面积公式如下：

area?s*(s?a)*(s?b)*(s?c)，其中a、b、c为三角形的三条边，s=(a+b+c)/2。

【编程分析】该程序由于涉及到数据输入，因此首先建立输入流对象，输入三角形三条边a、b、c的值，然后求出中间变量s的值，最后利用数学方法Math.sqrt()方法求出三角形的面积并输出。 【参考程序】 import java.io.*; public class X2_3_3 {

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

InputStreamReader isr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(isr);

double a, b, c, s, area; String str; str = br.readLine(); } 4

a = Double.parseDouble(str); b = Double.parseDouble(str); str = br.readLine();

c = Double.parseDouble(str); s = (a+b+c)/2.0;

area = Math.sqrt(s*(s-a)*(s-b)*(s-c)); System.out.println(\

str = br.readLine();

}

【运行结果】 3 4 5 area = 6.0

注意：输入的三角形的三条边必须满足三角形的构成规则，如果不满足则输出错误结果。

4．编写一个Java Application类型的程序，从键盘上输入摄氏温度C，计算华氏温度F的值并输出。其转换公式如下：

F = (9 / 5) * C + 32

【编程分析】该程序和上一个程序类似，在此不再赘述。 【参考程序】

import java.io.*; public class X2_3_4 {

public static void main(String[] args) throws IOException{ InputStreamReader isr = new InputStreamReader(System.in); } } 【运行结果】

37 F = 69.0

5．已知圆球的体积公式为4/3?r3，编一程序，输入圆球半径，计算并输出球的体积。 【编程分析】该程序和第3题类似，在此不再赘述。 【参考程序】

import java.io.*; public class X2_3_5 {

public static void main(String[] args) throws IOException{ InputStreamReader isr = new InputStreamReader(System.in);

BufferedReader br = new BufferedReader(isr);

int radius; double volume; String str;

System.out.print(\ str = br.readLine(); radius = Integer.parseInt(str);

volume=4*Math.PI*Math.pow(radius,3)/3; System.out.println(\ } } 【运行结果】 5

BufferedReader br = new BufferedReader(isr); double C, F; String str; str = br.readLine(); F=(9 / 5) * C + 32;

C = Double.parseDouble(str); System.out.println(\

Enter the value of radius please: 26 volume = 73622.17663932561 第三章 一、选择题

1．下列（ D ）不属于Java语言流程控制结构？

（A）分支语句

（B）跳转语句

（C）循环语句

（D）赋值语句

【解析】Java语言流程控制结构只包括分支、循环和跳转三种语句。 2．假设a是int类型的变量，并初始化为1，则下列（ D ）是合法的条件语句？

（A）if(a){}

（B）if(a<<=3){}

（C）if(a=2){}

（D）if(true){}

【解析】条件语句中的“条件表达式”只能是boolean类型，不能是其他类型。 3．下列说法中，不正确的一个是（ C ）。

（A）switch语句的功能可以由if…else if语句来实现 （B）若用于比较的数据类型为double型，则不可以用switch语句来实现 （C）if …else if语句的执行效率总是比switch语句高 （D）case子句中可以有多个语句，并且不需要大括号{}括起来 【解析】语句的执行效率高低要根据具体语句来确定，不能简单地说if …else if语句的执行效率总是比switch语句高。 4．设a、b为long型变量，x、y为float型变量，ch为char类型变量且它们均已被赋值，则下列语句中正确的是（ B ）。

（A）switch(x+y) {} （B）switch(ch+1) {} 5．下列循环体执行的次数是（ C ）。

int y=2, x=4; while(--x != x/y){ } （A）1

（B）2

（C）3

（D）4

【解析】第1次执行while时，--x的值为3，3/2=1，满足等号两端值不等的条件，执行一次循环体；第2次执行while时，--x的值为2，2/2=1，条件满足，又执行一次循环体；第3次执行while时，--x的值为1，1/2=0，条件满足，再次执行一次循环体；第4次执行while时，--x的值为0，0/2=0，条件不满足满足，结束循环。因此在这个循环语句执行的过程中，循环体共执行了3次。 6．下列循环体执行的次数是（ B ）。

int x=10, y=30; do{ y -= x; x++; （A）1

}while(x++

（C）3

（D）4

（C）switch ch {}

（D）switch(a+b); {}

【解析】switch后面的表达式必须放在括号()中，且表达式的类型只能是byte、short、int和char类型，不能是其他类型。

【解析】执行1次循环体后，y的值为20，x值为11，然后执行while，此时x++的值为11，y—的值为20，因此x++

7．已知如下代码：

switch(m){ }

当m的值为（ D ）时，输出“Condition 3” （A）2 续向后执行。 二、填空题

1．跳转语句包括break、continue、return和throw 6

（B）0、1

（C）0、1、2

（D）0、1、2、3

【解析】当m的值为0、1、2、3时，都能输出“Condition 3”，因为case 0、case 1、case 2后面的语句都没有break，因此可以继

case 0: System.out.println(\case 1: System.out.println(\case 2: System.out.println(\case 3: System.out.println(\default:System.out.println(\

2．switch语句先计算switch后面的 表达式 的值，再和各 case 语句后的值做比较。 3．if语句合法的条件值是 boolean 类型。 4．continue语句必须使用于 循环 语句中。

5．break语句有两种用途：一种从switch 语句的分支中跳出，一种是从循环语句内部跳出。 6．do － while循环首先执行一遍 循环体 ，而while循环首先判断 表达式的值 。 7．与C++语言不同，Java语言不通过 goto 语句实现跳转。

8．每一个else子句都必须和它前面的一个距离它最近的 if 子句相对应。

9．在switch语句中，完成一个case语句块后，若没有通过break语句跳出switch语句，则会继续执行后面的 case 语句块。 10．在for循环语句中可以声明变量，其作用域是 for循环体 。 三、写出下列程序的运行结果

1． public class X3_3_1 {

public static void main(String[] args) {

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

} } }

【运行结果】01234

【程序解析】本程序主要考查break语句的使用。程序中的for循环变量i是从0到9进行循环，正常情况下应该输出0到9，但是由于循环体中有“if(i==5) break;”语句，当i为5时for循环就结束了，因此最后的结果是01234。 2．public class X3_3_2 {

public static void main(String[] args) {

int i=5, j=2; while(j

【运行结果】4

【程序解析】本程序主要考查while语句以及“后缀--”运算符的使用。由于每执行一次while判断，i的值就减1，每执行1次循环体，j的值就增加1，而while判断总共经历了“2<5”、“3<4”、“4<3”三次，第3次时由于条件不满足，还没有执行循环体就结束了循环，因此循环体总共执行了2次，j的值也只加了2，而其初始值为2，因此j最后的值为4。 3．public class X3_3_3 {

public static void main(String[] args) {

int i=4;

while(--i>0){ } System.out.print(i); } }

【运行结果】0

【程序解析】本程序主要考查while语句以及“前缀--”运算符的使用。由于i的初值为4，要使“while(--i>0)”结束执行，必须等到i的为0，因此i最后的值为0。 4．public class X3_3_4 {

public static void main(String[] args) {

int j=0;

j += i;

for(int i=3; i>0; i--){

7

if(i==5) break;

System.out.print(i);

} } }

int x = 2; while(x

System.out.print(x); }

【运行结果】33453456

【程序解析】本程序主要考查for循环和while循环嵌套的情况。在for循环第1次执行到while语句时，j和x的值分别为3和2，此时“while(x0”条件满足，进入for循环体。在for循环第2次执行到while语句时，j和x的值分别为5和2，此时“while(x0”条件不满足，退出for循环，结束程序执行。 5． public class X3_3_5 {

public static void main(String[] args) { int i=8, j=2; while(j< --i) } }

【运行结果】6

【程序解析】本程序主要考查while循环和for循环嵌套执行的情况。第1次执行“while(j< --i)”时，j和—i的值分别为2和7，条件满足，执行for循环，for循环体共执行了4次，j的值增4，变为6；然后又第2次执行“while(j< --i)”，此时j和—i的值分别为6和6，条件不满足，结束while循环，输出j的值。 6． public class X3_3_6 {

public static void main(String[] args) {

int a=0, b=1;

if(b%2==0)

a += b;

do{ b++;

}while(b <= 100); System.out.print(a); } }

【运行结果】2550

【程序解析】本程序主要考查do…while循环的执行情况。执行循环体之前，a=0，b=1，进入循环体后，由于“b%2==0”的条件不满足，因此直接执行“b++”，b的值变为2，满足“while(b <= 100)”条件，再次进入循环体。此时“b%2==0”的条件满足，语句“a+=b”执行，然后执行“b++”，再进行“while(b <= 100)”判断，如此一直执行下去，直至该条件不满足为止，最后输出a的值。从循环过程来看，只有b为偶数时才加到a中去，因此a的值应该是“2+4+6+…+100”。 7． public class X3_3_7 {

public static void main(String[] args) { for(int i=1; i<=10; i++){

8

for(int k=0; k<4; k++) j++;

System.out.print(j);

} } }

if(i<=5) continue;

System.out.print(i + \

【运行结果】6 7 8 9 10

【程序解析】本程序主要考查continue语句的使用情况。由于“if(i<=5) continue;”语句，使得for循环变量i从1到5的循环过程中都不能执行“System.out.print(i + \”，只有i的值从6到10时才执行该语句，因此输出结果为“6 7 8 9 10”。 8． public class X3_3_8 {

public static void main(String[] args) { char ch='7'; int r=10; switch(ch+1){ }

System.out.print(r); } }

【运行结果】27

【程序解析】本程序主要考查switch…case语句，由于“ch+1”的值是'8'，因此程序执行了“r += 8;”语句，由于该语句后没有break，因此又执行了后面的“r += 9;”语句，由于r的初值为10，因此r最后的值为27。 9． public class X3_3_9 {

public static void main(String[] args) { lable:

} }

【运行结果】3 6 7

【程序解析】本程序主要考查continue lab语句的运行情况。当程序执行到“continue lable;”语句时，程序直接跳转到外层for循环，执行下一次循环。

10． public class X3_3_10 {

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

a1: for(int i=3; i>0; i--){

9

j += i;

for(int k=1; k<3;k++){ }

j *= k; if(i==k)

break a1;

a2:

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

for(int j=0; j<3; j++){ }

System.out.print(\

if(i==j) continue lable; System.out.print(i*3+j+\case '7': r += 7; case '8': r += 8; case '9': r += 9;

default:

}

}

}

System.out.println(\

}

【运行结果】j= 16

【程序解析】本程序主要考查break lab语句的执行情况。当程序执行到“break a1;”时，程序流程直接跳出a1所在的外层for循环，输出j的值。 四、编写程序

1．利用if语句，根据下列函数编写一个程序，当键盘输入x值时，求出并输出y的值。

y = x (x<=1) 3x-2 (1=10) 【编程分析】本题主要考查if…else语句的使用。根据给定的数学算式，只要给出x的值，就有对应的y算式，因此利用if…else语句直接可以实现。

【参考程序】 import java.io.*; public class X3_4_1 {

public static void main(String[] args) throws IOException{ } 【运行结果】

9 x = 9 y = 25

2．利用switch语句将学生成绩分级，当从键盘中输入学生成绩在100～90范围时，输出“优秀”，在89～80范围时输出“良好”，在79～70范围时输出“中等”，在69～60范围时输出“及格”，在59～0范围时输出“不及格”，在其他范围时输出“成绩输入有误！”。 【编程分析】本题主要考查switch语句的使用。由于要根据一定的数值范围来输出相应的汉字，而switch后面的表达式类型不能是一个范围，因此要把一个整数范围变成一个整数来满足要求。由于Java中的int和int运算的结果还是int型，可以把某个给定的程序除10，如89/10和81/10的结果都是8，这样就满足了要求。 【参考程序】

import java.io.*;

public class X3_4_2 {

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

InputStreamReader isr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(isr); int score, k;

score = Integer.parseInt(br.readLine()); if(score>100 || score<0){

InputStreamReader isr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(isr); int x, y;

x = Integer.parseInt(br.readLine()); if(x<=1) y = x;

else if(x<10) y = 3*x - 2; else y=4*x;

System.out.println(\

}

}

}

System.out.println(\输入成绩超出范围！\System.exit(1);

k = score/10; switch(k){ }

case 10: case 9:

System.out.println(\优秀\ break;

System.out.println(\良好\ break;

System.out.println(\中等\ break;

System.out.println(\及格\ break;

System.out.println(\不及格\

case 8:

case 7:

case 6:

default:

} 【运行结果】

87 良好

3．利用for循环，计算1+3+7+??+（220-1）的和。

【编程分析】本例主要考查利用for循环求一个数列的和的编程方法。数列的项数和每一项的值都已知，因此直接利用for循环和数学类中的相应方法即可实现。 【参考程序】

public class X3_4_3 {

public static void main(String[] args) { int i, sum=0; for(i=1; i<21; i++)

sum += Math.pow(2,i) - 1; System.out.println(\ } } 【运行结果】

sum = 2097130 4．已知S?1?11111??????，利用while循环编程求解n=100时的S值。 234n?1n【编程分析】本例主要考查利用while循环实现对一个数列进行加、减运算的编程方法。由于项数已经确定，因此数列的首项和末项已知，但是由于加减交替出现，可以利用一个变量sign来确定符号，设sign初始值为1，循环一次让它变一次符号，从而实现符号的交替变化。 【参考程序】

public class X3_4_4 { 11

public static void main(String[] args) { int i=1, n = 100; double sign = 1, sum = 0; while(i<=n){ double k = sign/i; sum += k; i++; sign = -sign; }

System.out.println(\ } } 【运行结果】

S = 0.688172179310195

5．利用do…while循环，计算1!+2!+3! +??+100!的和。

【编程分析】本例主要考查利用do…while循环实现数列相加的程序设计方法。由于每一项都是一个阶乘，所以在循环过程中先求阶乘，然后再相加。 【参考程序】

public class X3_4_5 {

public static void main(String[] args) { int i=1;

long fact = 1, sum = 0; do{ fact *= i; sum += fact; i++;

} while(i<=100) ;

System.out.println(\ } } 【运行结果】

sum = 1005876315485501977

7．编写打印“九九乘法口诀表”的程序。

【编程分析】本例主要考查利用循环嵌套进行程序设计的方法。“九九乘法口诀表”既涉及到行，又涉及到列，因此需要利用循环嵌套来实现，实现时还需要注意输出格式。 【参考程序】

public class X3_4_7 {

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

for(i=1;i<10;i++){ for(j=1;j<=i;j++) } } } 【运行结果】 12

System.out.print(i + \

System.out.println(\

1x1=1

2x1=2 2x2=4

3x1=3 3x2=6 3x3=9

4x1=4 4x2=8 4x3=12 4x4=16

5x1=5 5x2=10 5x3=15 5x4=20 5x5=25

6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36

7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49

8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64

9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81

9．水仙花数是指其个位、十位和百位三个数的立方和等于这个三位数本身，求出所有的水仙花数。

【编程分析】本例主要考查如何利用循环结构将一个多位整数拆分成多个个位数的程序设计方法。在求“水仙花数”过程中，需要将这个百位的数拆分成3个个位数。 【参考程序】

public class X3_4_9 {

public static void main(String[] args) { for(int i=100;i<=999;i++){ int k = i; int gw = k % 10; k /= 10; int sw = k % 10; k /= 10; int bw = k;

int sum = (int)(Math.pow(gw,3)+Math.pow(sw,3)+Math.pow(bw,3)); if(i == sum) } } } 【运行结果】

153 370 371 407

10．编写一个程序，接受用户输入的两个数据为上、下限，然后输出上、下限之间的所有素数。

【编程分析】本例主要考查如何利用Java语言的流程控制语句解决求素数的问题。由于素数是除了能被1和它本身整除外，不能被其他任何整数整除的自然数。假设要判断某数i是否为素数，可以利用循环语句让该数分别除以2～i-1之间的所有数，如果一直不能整除，则i是素数，否则不是。如果让i分别除以2～i/2之间的所有数，如果一直不能整除，则i也是素数，因为任何数都不可能被大于它一半的数整除，这样可以减少循环次数，提高程序运行效率。另外，数学原理证明，如果让i分别除以2～(int)如果一直不能整除，则i也是素数，这样就可以大大减少循环次数，提供程序效率。 【参考程序】

import java.io.*;

public class X3_4_10 {

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

InputStreamReader isr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(isr); int top, bottom, i, j;

System.out.print(\请输入上限：\top = Integer.parseInt(br.readLine()); System.out.print(\请输入下限：\System.out.print(i+ \

i之间的所有数，

}

bottom = Integer.parseInt(br.readLine()); if(top

for(i=bottom; i<=top; i++){ }

System.out.println();

int k = (int)Math.sqrt(i); for(j=2; j<=k; j++){ }

if(j>k) System.out.print(i + \

if(i % j == 0) break;

System.out.println(\输入的上、下限不正确！\System.exit(1);

} 【运行结果】

请输入上限：500 请输入下限：100

101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 第四章 一、选择题

1．下列哪种类成员修饰符修饰的变量只能在本类中被访问？（ D ） （A）protected

（B）public

（C）default

（D）private

【解析】只有私有访问权限修饰符才能限制变量只能在本类中被访问。 2．在Java语言中，哪一个包中的类是自动导入的？（ A ） A）java.lang

B）java.awt

C）java.io

D）java.applet

【解析】只有java.lang包中的类能够被自动导入。 3．给出下面的程序代码：

public class X4_1_3 {

}

如何使成员变量a被方法m( )访问（ C ）

A）将private float a改为protected float a（B将private float a改为public float a（C将private float a改为static float a（D将private float a改为float a

【解析】static类型的方法只能访问static类型的数据成员。 4．有一个类B，下面为其构造方法的声明，正确的是（ B ）。 （A）void B(int x) {}

（B）B(int x) {}

（C）b(int x)

{}

（D）void b(int x) {}

【解析】构造方法没有类型，且方法名与类名相同。 5．下面关于类的说法，不正确的是（ C ）。 14

private float a;

public static void m ( ){ }

（A）类是同种对象的集合和抽象 单位

（B）类属于Java语言中的复合数据类型（C）类就是对象 （D）对象是Java语言中的基本结构

【解析】类是对象的抽象，对象是类的实例，因此类和对象是有区别的。 6．下面关于方法的说法，不正确的是（ C ）。

（A）Java中的构造方法名必须和类名相同 （B）方法体是对方法的实现，包括变量声明和合法语句 （C）如果一个类定义了构造方法，也可以用该类的默认构造方法 （D）类的私有方法不能被其他类直接访问

【解析】类中一旦用户定义了构造方法，该类默认的构造方法就不存在了，除非用户再自定义该类的默认构造方法。

7．关于内部类，下列说法不正确的是（ A ）。

（A）内部类不能有自己的成员方法和成员变量 （B）内部类可用private或protected修饰符修饰

（C）内部类可以作为其他类的成员，而且可访问它所在的类的成员 （D）除static内部类外，不能在类内声明static成员

【解析】内部类也可以有自己的成员方法和变量。 8．定义外部类时不能用到的关键字是（ C ）。 （A）final

（B）public

（C）protected

（D）abstract

【解析】定义外部类不能使用protected修饰符。

9．为AB类定义一个无返回值的方法f，使得使用类名就可以访问该方法，该方法头的形式为（ D ） （A）abstract void f()（B）public void f()（C）final void f()（D）static void f()

【解析】只有static类型的方法才可以直接使用类名来引用。 10．定义一个公有double型常量PI，哪一条语句最好？（ B ）

（A）public final double PI; （B）public final static double PI=3.14; （C）public final static double PI;（D）public static double

PI=3.14;

【解析】用public final static来定义常量，既可以节省存储空间，又可以保证数值不会被改变。 二、填空题

1． 对象 是对事物的抽象，而 类 是对对象的抽象和归纳。

2．从用户的角度看，Java源程序中的类分为两种： 系统定义的类 和 用户自己定义的类 。 3．一个类主要包含两个要素： 数据成员 和 成员方法 。 4．创建包时需要使用关键字 package 。

5．类中的 构造 方法是一个特殊的方法，该方法的方法名和类名相同。

6．如果用户在一个自定义类中未定义该类的构造方法，系统将为这个类定义一个默认构造方法。这个方法没有 形式参数 ，也没有任何 具体语句 ，不能完成任何操作。

7．静态数据成员被保存在类的内存区的 公共存储 单元中，而不是保存在某个对象的内存区中。因此，一个类的任何对象访问它时，存取到的都是 相同 （相同/不同）的数值。

8．静态数据成员既可以通过 对象名 来访问，也可以通过 类名 直接访问它。

9．定义常量时要用关键字 final ，同时需要说明常量的 数据类型 并指出常量的 具体值 。

10．方法体内定义变量时，变量前不能加 修饰符 ；局部变量在使用前必须 明确赋值 ，否则编译时会出错；而类变量在使用前可以不用赋值，它们都有一个 默认 的值。

11．static方法中只能引用 static 类型的数据成员和 static 类型的成员方法；而非static类型的方法中既可以引用 static 类型的数据成员和成员方法，也可以引用非static 类型的数据成员和成员方法。

12．引用static类型的方法时，可以使用 类名 做前缀，也可以使用 对象名 做前缀。

13．当程序中需要引用java.awt.event包中的类时，导入该包中类的语句为 import java.awt.event.*。

14．定义类时需要 class 关键字，继承类时需要 extends 关键字，实现接口时需要关键字 implements 。 三、编程题

1．编一个程序，程序中包含以下内容： 一个圆类(Circle)，包含：

属性：圆半径radius；常量：PI。

方法：构造方法；求面积方法area()；求周长方法：perimeter()。 主类(X4_3_1)，包含： 15

主方法main()，在主方法中创建圆类的对象c1和c2并初始化，c1的半径为100，c1的半径为200，然后分别显示两个圆的面积和周长。

【编程分析】按照要求创建Circle类，其中的半径可以定义为int类型，PI定义为final static double类型，求面积和周长的方法都应定义为double类型，在构造方法中对radius进行初始化。 【参考答案】

public class X4_3_1 {

public static void main(String[] args) { Circle c1 = new Circle(100); Circle c2 = new Circle(200);

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

class Circle{ } 【运行结果】

c1.area() = 31400.0 c1.perimenter() = 628.0 c2.area() = 125600.0 c2.perimenter() = 1256.0 2．编一个程序，程序中包含以下内容：

一个学生类（Student），包含：

属性：学号s_No，姓名s_Name，性别s_Sex，年龄s_Age。

方法：构造方法，显示学号方法showNo()，显示姓名方法showName()，显示性别方法showSex()，显示年龄方法showAge()，修改年龄方法modifyAge()。

主类(X4_3_2)，包含：

主方法main()，在其中创建两个学生对象s1和s2并初始化，两个对象的属性自行确定，然后分别显示这两个学生的学号、姓名、性别、年龄，然后修改s1的年龄并显示修改后的结果。

【编程分析】按照要求首先编写Student类，其中的属性和方法根据实际情况选择相应的类型和权限修饰符，要通过方法来修改年龄，因此s_Age属性应该为private类型，否则可以直接在主类中进行修改，就没有必要使用方法了。 【参考答案】

public class X4_3_2 {

public static void main(String[] args) {

Student s1 = new Student(101,\张三\男\ Student s2 = new Student(102,\李四\女\ System.out.println(\第1个学生的信息为：\ s1.showNo(); s1.showName(); 16

int radius;

final static double PI=3.14; Circle(int r){ }

double area(){ }

double perimeter(){ }

return 2*PI*radius; return PI*radius*radius; radius = r;

s1.showSex(); s1.showAge();

System.out.println(\第2个学生的信息为：\ s2.showNo(); s2.showName(); s2.showSex(); s2.showAge();

System.out.println(\修改第1个学生的年龄：\ s1.modifyAge(24);

System.out.println(\第1个学生的年龄修改为：\ s1.showAge(); } }

class Student{ } 【运行结果】

第1个学生的信息为： 学号：101 姓名：张三 性别：男 年龄：18

第2个学生的信息为： 17

private int s_No; private String s_Name; private String s_Sex; private int s_Age;

Student(int no, String name, String sex, int age){ }

void showNo(){ }

void showName(){ }

void showSex(){ }

void showAge(){ }

void modifyAge(int newAge){ }

s_Age = newAge;

System.out.println(\年龄：\System.out.println(\性别：\System.out.println(\姓名：\System.out.println(\学号：\s_No = no; s_Name = name; s_Sex = sex; s_Age = age;

学号：102 姓名：李四 性别：女 年龄：16

修改第1个学生的年龄： 第1个学生的年龄修改为： 年龄：24 第四章（续） 一、选择题

1．已知有下面类的说明：

public class X5_1_1 extends x{ private float f =10.6f; int i=16; static int si=10;

public static void main(String[] args) { X5_1_1 x=new X5_1_1(); } }

在main()方法中，下面哪条语句的用法是正确的？（ A ） A．x.f

B．this.si

C．X5_1_1.i

D．X5_1_1.f

【解析】由于x是在main方法内部定义的对象，因此它可以引用类的非static类型的属性，因此选A，而this和super不能在main方法中使用，使用类名只能引用本类的静态属性，因此B、C、D不对。 2．下列程序的运行结果是（ C ）。

public class X5_1_2 extends x{

int ab(){ static int aa=10; aa++; System.out.println(aa); }

public static void main(String[] args) { X5_1_2 x=new X5_1_2(); x.ab(); } }

A．10 B．11 C．编译错误 D．运行成功，但不输出 【解析】方法体内的局部变量不能使用static修饰符。 3．下面关于接口的说法中不正确的是（ C ）。

A．接口中所有的方法都是抽象的 B．接口中所有的方法都是public访问权限

C．子接口继承父接口所用的关键字是implements D．接口是Java中的特殊类，包含常量和抽象方法 【解析】子接口继承父接口所用的关键字也是extends，只有类实现接口时才使用implements。 4．区分类中重载方法的依据是（ A ）。

A．形参列表的类型和顺序 B．不同的形参名称 C．返回值的类型不同 D．访问权限不同 【解析】形参表的类型和顺序不同时区分重载方法的唯一标志。

5．子类对象能否直接向其父类赋值？父类对象能否向其子类赋值？（ B ）

A．能，能

B．能，不能

C．不能，能

D．不能，不能

【解析】子类对象可以直接赋值给父类对象，而父类对象不能直接赋值给子类对象。 6．Java语言类间的继承关系是（ A ）。

A．单继承

B．多重继承

C．不能继承

D．不一定

【解析】Java语言类间的继承关系是单继承，但一个类可以实现多个接口。 7．Java语言接口间的继承关系是（ B ）。

A．单继承 18

B．多重继承

C．不能继承

D．不一定

【解析】Java语言接口间的继承关系允许多重继承。 8．一个类实现接口的情况是（ A ）。

A．一次可以实现多个接口B．一次只能实现一个接口C．不能实现接口D．不一定 【解析】Java语言允许一个类一次实现多个接口。 9．定义外部类的类头时，不可用的关键字是（ C ）。

A．public

B．final

C．protected

D．abstract

【解析】定义外部类时不能使用protected关键字。

10．如果局部变量和成员变量同名，如何在局部变量作用域内引用成员变量？（ B ）

A．不能引用，必须改名，使它们的名称不相同 B．在成员变量前加this，使用this访问该成员变量 C．在成员变量前加super，使用super访问该成员变量 D．不影响，系统可以自己区分 【解析】this可以用来引用本类对象。 11．下面说法不正确的是（ B ）。

A．抽象类既可以做父类，也可以做子类 B．abstract和final能同时修饰一个类

C．抽象类中可以没有抽象方法，有抽象方法的类一定是抽象类或接口 D．声明为final类型的方法不能在其子类中重新定义 【解析】abstract和final不能同时修饰一个类，因为abstract类需要子类，而final类不能有子类。 二、填空题

1．消息就是向对象发出 服务请求 ，是对 数据成员 和 成员方法 的引用。 2．在面向对象系统中，消息分为两类 公有消息 和 私有消息 。

3．在面向对象程序设计中，采用 继承 机制可以有效地组织程序结构。充分利用已有的类来创建更复杂的类，大大提高程序开发的

效率，提高代码的复用率，降低维护的工作量。

4． 数据成员的隐藏 是指在子类中重新定义一个与父类中已定义的数据成员名完全相同的数据成员。 5．子类可以重新定义与父类同名的成员方法，实现对父类方法的 覆盖 。

6．子类在重新定义父类已有的方法时，应保持与父类完全相同的 方法名 、 返回值类型 和 参数列表 ，否则就不是方法的覆盖，而

是

子

类

定

义

自

己

特

有

的

方

法

，

与

父

类

的

方

法

无

关

。

7．this代表了 当前对象 的一个引用，super表示的是当前对象的 直接父类对象 的引用。 8．抽象类不能 创建 对象，该工作由抽象类派生的非抽象子类来实现。

9．如果父类中已有同名的abstract方法，则子类中就 不能 （能/不能）再有同名的抽象方法。 10．abstract类中不能有 private 访问权限的数据成员或成员方法。

11． interface 是声明接口的关键字，可以把它看成一个特殊类。接口中的数据成员默认的修饰符是 public static final ，接口中的成

员方法默认的修饰符是 public abstract 。

12．如果实现某接口的类不是abstract的抽象类，则在类的定义部分必须 实现 该接口的所有抽象方法；如果实现某接口的类是abstract

的抽象类，则它可以 不实现 该接口所有的方法。但是对于这个抽象类任何一个非抽象的子类而言，它们父类所实现的接口中的所有抽象方法以及自身所实现接口中的抽象方法都必须有实在的 方法体 。 13．包的作用有两个，一是 划分类名空间 ，二是 控制类之间的访问 。

14．封装也称 信息隐藏 ，是指类的设计者只为类的使用者提供类的可以访问的部分（包括类的数据成员和成员方法），而把类中的

其他成员 隐藏 起来，使用户不能访问的机制。

15．Java提供了4种访问权限来实现封装机制，即 private 、 protected 、 默认 和 public 。 16．Java中提供两种多态机制， 重载 与 覆盖 。

17．当一个构造方法需要调用另一个构造方法时，可以使用关键字 this ，同时这个调用语句应该是整个构造方法的 第一条 可执行

语句。

18．如果子类自己没有构造方法，那么父类也一定 没有 （有/没有）带参的构造方法，此时它将继承父类的 无参构造方法 作为自

己的构造方法；如果子类自己定义了构造方法，则在创建新对象时，它将先执行 父类 的构造方法，然后再执行自己的 构造方法 。

19．对于父类的含参数构造方法，子类可以通过在自己的构造方法中使用 super 关键字来调用它，但这个调用语句必须是子类构造方

法的 第一条 可执行语句。

20．创建一个名为myPachkage的包的语句为 package myPackage; ，该语句应该放在程序第一行 位置。 三、编程题 19

1．编写一个实现方法重载的程序。

【编程分析】重载的含义就是在一个类中定义多个具有相同方法名，不同参数列表的方法。在下面程序中的类中定义了三个同名方法area，分别用于求圆、矩形和三角形的面积。三个方法具有不同的参数。 【参考程序】

public class X5_3_1{ } 【运行结果】

The area of circle is: 314.1592653589793 The area of rectangle is: 200.0

The area of triangle is: 72.61843774138907 2．编写一个实现方法覆盖的程序。

【编程分析】方法覆盖是指在子类中重新定义了父类中的方法。本例中在Shape类、Circle类、Cylinder类中都定义了area方法，而且Cylinder类继承了Circle类、Circle类继承了Shape类，从而实现了area方法的覆盖。 【参考程序】

abstract class Shape { }

class Circle extends Shape{

float r;

public Circle(float a) { }

public double area(){

System.out.print(\ \return Math.PI*r*r; r=a;

abstract protected double area(); public double area(double radius){ }

public double area(double width, double height){ }

public double area(double a, double b, double c){ }

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

X5_3_1 shape = new X5_3_1();

System.out.println(\System.out.println(\System.out.println(\double s = (a+b+c)/2;

return Math.sqrt(s*(s-a)*(s-b)*(s-c)); return width*height; return Math.PI*radius*radius;

} }

class Cylinder extends Circle { 20

float h;

public Cylinder(float a,float b) {

super(a); h=b;

} }

public double area() { }

System.out.print(\ \ return 2*Math.PI*r*r+2*Math.PI*r*h;

public class EX5_3_2 { } 【运行结果】

Calculate the area of circle: 28.274333882308138 Calculate the area of cylinder: 87.96459430051421

5．编写一个人类Person，其中包含姓名、性别和年龄的属性，包含构造方法以及显示姓名、性别和年龄的方法。再编写一个学生类Student，它继承Person类，其中包含学号属性，包含构造方法以及显示学号的方法。最后编写一个主类X5_3_5，包含main()方法，在main()方法中定义两个学生s1和s2并给他们赋值，最后显示他们的学号、姓名、性别以及年龄。 【编程分析】本题主要考察类的继承问题。

第一步：定义Person类。

第二步：定义Student类，该类继承Person类。 第三步：定义主类。 【参考程序】

public class X5_3_5 {

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

class Person{ 21

String name; String sex; int age;

public Person(String n,String s,int a){ name = n; sex = s; age = a; }

void show(){

Student s1=new Student(\ Student s2=new Student(\ s1.show(); s1.showID(); s2.show(); s2.showID();

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

Circle cl=new Circle(3); Cylinder cd=new Cylinder(2,5); System.out.println(cl.area()); System.out.println(cd.area());

}

}

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

class Student extends Person{ } 【运行结果】

name: Zhangsan sex: Male age: 20 sID: 102A name: Lisi sex: Female age: 18 sID: 108S

第2-4章（数组概念及应用） 一、选择题

1．给出下面程序代码：

byte[] a1, a2[]; byte a3[][]; byte[][] a4;

下列数组操作语句中哪一个是不正确的？（ A ） A．a2 = a1

B．a2 = a3

C．a2 = a4

D．a3 = a4

【解析】只有维数相同的数组才能相互赋值。 2．关于数组，下列说法中不正确的是（ C ）。

A．数组是最简单的复合数据类型，是一系列数据的集合 B．数组元素可以是基本数据类型、对象或其他数组 C．定义数组时必须分配内存 D．一个数组中所有元素都必须具有相同的数据类型 【解析】数组元素可以是基本数据类型、对象或其他数组。 3．设有下列数组定义语句：

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

则对此语句的叙述错误的是（ C ）。

A．定义了一个名为a的一维数组 B．a数组有3个元素C．a数组元素的下标为1～3 D．数组中每个元素的类型都是整数 【解析】数组元素的下标是从0开始的。

4．执行语句：int[] x = new int[20];后，下面哪个说法是正确的？（ C ） A．x[19]为空

B．x[19]未定义

C．x[19]为0

D．x[0]为空

【解析】此语句定义了x数组后，x[0]~x[19]的值全部为0。 5．下面代码运行后的输出结果为（ A ）。

public class X6_1_5 {

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

String sID;

public Student(String n,String s,int a,String sid){ super(n,s,a); sID = sid; }

void showID(){

System.out.println(\}

AB aa = new AB(); AB bb; bb = aa; System.out.println(bb.equals(aa)); } }

class AB{ int x = 100; } A．true B．false C．编译错误 6．已知有定义：String s=\，下面哪个表达式正确？（ A ） A．s += \

D．100

【解析】同一个类的两个对象可以相互赋值，赋值后两个对象具有相同的存储空间，因此是相同的。

B．char c = s[1];C．int len = s.length; D．String s = s.toLowerCase();

【解析】字符串对象可以执行“+=”运算，但不能用s[1]这种方式取其中的字符，也不能用length求它的长度，可以用length()求其长度，因此B、C不正确，不能再次定义s字符串，因此D不正确。 二、填空题

1． Object类 是所有类的直接或间接父类，它在 java.lang 包中。

2．System类是一个功能强大、非常有用的特殊的类，它提供了 标准输入/输出 、 运行时 系统信息等重要工具。这个类不能 实例化 ，即不能创建System类的对象，所以它所有的属性和方法都是 static 类型，引用时以类名System为前缀即可。 4．数组是一种 复合 数据类型，在Java中，数组是作为 对象 来处理的。数组是有限元素的有序集合，数组中的元素具有相同

的 数据类型 ，并可用统一的 数组名 和 下标 来唯一确定其元素。

5．在数组定义语句中，如果[]在数据类型和变量名之间时，[]之后定义的所有变量都是

数组 类型，当[]在变量名之后时，只有[]之前的变量是 数组 类型，之后没有[]的则不是数组类型。 6．数组初始化包括 静态 初始化和 动态 初始化两种方式。 三、写出下列程序的运行结果 1．public class X6_3_1 {

public static void main(String[] args) { int a[]={12,39,26,41,55,63,72,40,83,95}; int i1=0,i2=0; for(int i=0;i

【运行结果】 6 4

2．public class X6_3_2 {

public static void main(String[] args) { int a[]={36,25,48,14,55,40,32,66}; int b1,b2; b1=b2=a[0]; for(int i=1;ib1 ){ if ( b1 >b2 ) b2=b1; b1=a[i]; } System.out.println(b1+\ } }

【运行结果】 66 55

3．public class X6_3_3 {

23

public static void main(String[] args) { int a[]={36,25,48,14,55,40,32,66 }; int b1,b2; b1=b2=a[0]; for (int i=1;i

if ( a[i]

【运行结果】 14 25

4．public class X6_3_4 {

public static void main(String[] args) { String str = \ char[] a =str.toCharArray(); int i1 =0, i2=0, i; for(i=0;i

【运行结果】 4 3

5．public class X6_3_5 {

public static void main(String[] args) { String str =\ char[] a = str.toCharArray(); int b[] = new int[5],i; for(i=0;i

【运行结果】

4 3 2 2 3 6．public class X6_3_6 {

public static void main(String[] args) { int a[] = {76,83,54,62,40,75,90,92,77,84}; int b[] = {60,70,90,101}; int c[]=new int[4],i;

for (i=0; i

while (a[i] >= b[j] ) j ++; c[j] ++; }

for (i=0; i<4; i++) System.out.print(c[i]+\ System.out.println(); } }

【运行结果】 24

2 1 5 2 7．public class X6_3_7 {

public static void main(String[] args) { int a[][] = {{1,2,7,8},{5,6,11,12},{9,10,3,4}}; int m = a[0][0]; int ii = 0, jj = 0;

for (int i=0;im ){ m =a[i][j]; ii =i; jj =j; }

System.out.println(ii+\ } }

【运行结果】

1 3 12

8．public class X6_3_8 {

public static void main(String[] args) { String[] a = {\ String s1,s2; s1 = s2 = a[0];

for( int i = 1; i0) s1=a[i]; if (a[i].compareTo(s2)<0) s2=a[i]; }

System.out.println(s1+\ } }

【运行结果】 worker cadre 四、编程题

1．有一个数列，它的第一项为0，第二项为1，以后每一项都是它的前两项之和，试产生该数列的前20项，并按逆序显示出来。 【编程分析】本例由于涉及到20项数据的存储，因此可以利用数组来实现。由于数列的各项之间存在一定的关系，可以利用前两项来计算后面项。 【参考答案】

public class X6_4_1 {

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

int[] a = new int[20]; a[0]=0; a[1]=1; int i;

for(i=2;i<20;i++){ }

for(i=0;i<20;i++){

if(i%5 == 0)

// 每一行显示5个元素

a[i]=a[i-1]+a[i-2];

// 求其余18项

System.out.println();

System.out.print(a[i]+\

}

System.out.println();

}

【运行结果】

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 第7章（异常部分） 一、选择题

1．关于异常的含义，下列描述中最正确的一个是（ D ）。

A．程序编译错误B．程序语法错误C．程序自定义的异常事件D．程序编译或运行时发生的异常事件 【解析】异常就是程序编译或运行时发生的异常事件。

3．对应try和catch子句的排列方式，下列哪一项是正确的？（ A ）

A．子类异常在前，父类异常在后 B．父类异常在前，子类异常在后C．只能有子类异常 D．父类和子类不能同时出现在try语句块中

【解析】对应try和catch子句的排列方式，要求子类异常（范围小的异常）在前，父类异常（范围大的异常）在后。 4．运行下面程序时，会产生什么异常？（ A ）

public class X7_1_4 {

public static void main(String[] args) { int x = 0; int y = 5/x; int[] z = {1,2,3,4}; int p = z[4]; } }

A．ArithmeticException B．NumberFormatException C．ArrayIndexOutOfBoundsException

D．IOException

【解析】当程序执行到“int y = 5/x”语句时，发生异常，程序中止执行，因此发生ArithmeticException异常。 5．运行下面程序时，会产生什么异常？（ C ）

public class X7_1_5 {

public static void main(String[] args) { int[] z = {1,2,3,4}; int p = z[4]; int x = 0; int y = 5/x; } }

A．ArithmeticException B．NumberFormatExceptionC．ArrayIndexOutOfBoundsException D．IOException

【解析】当程序执行到“int p = z[4]”语句时，发生异常，程序中止执行，因此发生ArrayIndexOutOfBoundsException异常。 6．下列程序执行的结果是（ B ）。

public class X7_1_6 {

public static void main(String[] args) { try{ return; } finally{ System.out.println(\ } }

} A．程序正常运行，但不输出任何结果 B．程序正常运行，并输出Finally C．编译通过，但运行时出现异常D．因为没有catch子句，因此不能通过编译

【解析】在执行try-catch-finally语句块时，最后必须执行finally语句块中的内容，而本程序没有异常发生，因此程序正常运行，并输出Finally。

8．下列描述了Java语言通过面相对象的方法进行异常处理的好处，请选出不在这些好处范围之内的一项（ C ） A．把各种不同的异常事件进行分类，体现了良好的继承性B．把错误处理代码从常规代码中分离出来

C．可以利用异常处理机制代替传统的控制流程 D．这种机制对具有动态运行特性的复杂程序提供了强有力的支持 26

【解析】异常处理机制不能代替传统的流程控制。 二、填空题

3．所有的Java异常类都是系统类库中的 Exception 类的子类。

5．Java语言为我们提供了 try?catch 语句和try?catch?finally 语句捕捉并处理异常。 6．一个try块后面可能会跟着若干个 catch 块，每个 catch 块都有一个异常类名作为参数。

7．如果try语句块产生的异常对象被第一个catch块所接收，则程序的流程将 转向第一个catch块 ，catch语句块执行完毕后就 退出当前方法 ，try块中尚未执行的语句和其他的catch块将被 忽略 ；如果try语句块产生的异常对象与第一个catch块不匹配，系统将自动转到 第二个catch块 进行匹配。

8．由于异常对象与catch块的匹配是按照catch块的 先后 顺序进行的，所以在处理多异常时应注意认真设计各catch块的排列顺序。 第6章 一、选择题

2．Java语言提供处理不同类型流的类所在的包是（ D ）。

A．java.sql

B．java.util

C．java.net

D．java.io

【解析】java.io 包是Java语言提供处理不同类型流的类所在的包。

4．下列程序从标准输入设备读入一个字符，然后再输出到显示器，选择正确的一项填入―//x‖处，完成要求的功能（ B ）。

import java.io.*;

public class X8_1_4 { public static void main(String[] args) { char ch; try{ //x System.out.println(ch); } catch(IOException e){ e.printStackTrace(); } } }

A．ch = System.in.read(); B．ch = (char)System.in.read(); C．ch = (char)System.in.readln();

D．ch = (int)System.in.read();

【解析】System.in.read()方法返回的是字符对应的Unicode码，即返回的类型是int型，而ch是char类型，因此必须把方法的返回值强制转换为char类型才能把它赋值给ch变量。另外，System.in对象中没有readln()方法。

5．下列程序实现了在当前包dir815下新建一个目录subDir815，选择正确的一项填入程序的横线处，使程序符合要求（ D ）。

package dir815; import java.io.*;

public class X8_1_5 { public static void main(String[] args){ char ch; try{ File path = ; if(path.mkdir()) System.out.println(\ } catch(Exception e){ e.printStackTrace(); } } }

A．new File(\ B．new File(\ C．new File(\

D．new File(\

【解析】在程序中，目录之间的连接符是“\\\\”或“/”，因此首先排除B和C；而默认情况下，创建相对目录是在当前目录下进行，而dir815也在当前目录下，因此要在dir815下创建新的目录，就必须使用D的形式。 27

6．下列流中哪一个使用了缓冲区技术（ A ）？

A．BufferedOutputStream B．FileInputStream C．DataOutputStream 【解析】只有BufferedOutputStream使用了缓冲区技术。

7．能读入字节数据进行Java基本数据类型判断过虑的类是（ C ）。

A．BufferedInputStream

B．FileInputStream C．DataInputStream D．FileReader

【解析】DataInputStream类在读入字节数据时，进行Java基本数据类型判断过虑。 8．使用哪一个类可以实现在文件的任一个位置读写一个记录（ B ）？

A．BufferedInputStream

B．RandomAccessFile C．FileWriter D．FileReader

【解析】只有RandomAccessFile才能实现在文件的任一个位置读写一个记录。

9．在通常情况下，下列哪个类的对象可以作为BufferedReader类构造方法的参数（ C ）？

A．PrintStream B．FileInputStream C．InputStreamReader D．FileReader 【解析】InputStreamReader类的对象可以作为BufferedReader类构造方法的参数。

10．若文件是RandomAccessFile的实例f，并且其基本文件长度大于0，则下面的语句实现的功能是（ B ）。

f.seek(f.length()-1);

A．将文件指针指向文件的第一个字符后面

B．将文件指针指向文件的最后一个字符前面

D．FileReader

C．将文件指针指向文件的最后一个字符后面 D．会导致seek()方法抛出一个IOException异常

【解析】通过调用f对象的length()方法，可以将文件指针指向文件的末尾，因此f.length()-1即指向文件的最后一个字符前面。 11．下列关于流类和File类的说法中错误的一项是（ B ）。

A．File类可以重命名文件 B．File类可以修改文件内容C．流类可以修改文件内容 【解析】只有流类可以修改文件内容，而File类则不能。

12．若要删除一个文件，应该使用下列哪个类的实例（ B ）？

A．RandomAccessFile

B．File C．FileOutputStream

D．FileReader

【解析】要删除文件以及查看文件属性等，应使用File类对象来实现。 13．下列哪一个是Java系统的标准输入流对象（ B ）？

A．System.out B．System.in 是System类的退出方法。 二、填空题

2．凡是从外部设备流向中央处理器的数据流，称之为 输入 流；反之，称之为 输出 流。 4．所有的字节输入流都从 InputStream 类继承，所有的字节输出流都从 OutputSteam 类继承。

5．与用于读写字节流的InputStream类和OutputStream类相对应，Java还提供了用于读写Unicode字符的字符流 Reader 类和 Writer 类。 6．对一般的计算机系统，标准输入通常是 键盘 ，标准输出通常是 显示器 。

7．Java系统事先定义好两个流对象，分别与系统的标准输入和标准输出相联系，它们是 System.in 和 System.out 。 8．System类的所有属性和方法都是 Static类型 的，即调用时需要以类名System为前缀。

9．Java的标准输入System.in是 InputStream 类的对象，当程序中需要从键盘读入数据的时候，只需调用System.in的 read 方法即可。 14．在计算机系统中，需要长期保留的数据是以 文件 的形式存放在磁盘、磁带等外存储设备中的。 15． 目录 是管理文件的特殊机制，同类文件保存在同一 目录 下可以简化文件的管理，提高工作效率。

16．Java语言的java.io包中的 File 类是专门用来管理磁盘文件和目录的。调用 File 类的方法则可以完成对文件或目录的常用管理操作，如创建文件或目录、删除文件或目录、查看文件的有关信息等。

17．File类也虽然在java.io包中，但它不是InputStream或者OutputStream的子类，因为它不负责 数据的输入输出 ，而专门用来管理 文

件和目录 。

18．如果希望从磁盘文件读取数据，或者将数据写入文件，还需要使用文件输入输出流类

FileInputStream 和 FileOutputStream 。

19．Java系统提供的FileInputStream类是用于读取文件中的 字节 数据的 字节 文件输入流类；FileOutputStream类是用于向文件写入

字节 数据的 字节 文件输出流。 第7章（线程部分） 一、选择题 28

C．System.exit

D．System.err

【解析】System.in是Java系统的标准输入流对象，而System.out和System.err则是Java系统的标准输出流和标准错误对象，System.exit则

D．流类不可以新建目录

1．下列说法中，正确的一项是（ A ）。

A．单处理机的计算机上，2个线程实际上不能并发执行 B．单处理机的计算机上，2个线程实际上能够并发执行 C．一个线程可以包含多个进程 D．一个进程只能包含一个线程

【解析】单处理机的计算机上通过一个极短的固定时间段或者在线程等待时，切换到另一个线程，这种调度过程时间极短，看上去像是并发执行。

2．下列说法中，错误的一项是（ A ）。

A．线程就是程序 B．线程是一个程序的单个执行流 C．多线程是指一个程序的多个执行流 D．多线程用于实现并发 【解析】线程是一个程序的单个执行流，而不是程序本身。而多线程作为实现并发的一个重要手段，是一个程序的多个执行流。 3．下列关于Thread类的线程控制方法的说法中错误的一项是（ C ）。

A．线程可以通过调用sleep()方法使比当前线程优先级低的线程运行B．线程可以通过调用yield()方法使和当前线程优先级一样的线程运行C．线程的sleep()方法调用结束后，该线程进入运行状态D．若没有相同优先级的线程处于可运行状态，线程调用yield()方法时，当前线程将继续执行

【解析】线程的sleep()方法调用结束后，该线程进入就绪状态，而不是运行状态。 4．方法resume()负责恢复下列哪一个线程的执行（ D ）？

A．通过调用stop()方法而停止的线程B．通过调用sleep()方法而停止的线程 C．通过调用wait()方法而停止的线程 D．通过调用suspend()方法而停止的线程 【解析】通过调用suspend()方法而停止的线程需要调用resume()恢复。

5．下面的哪一个关键字通常用来对对象加锁，从而使得对对象的访问是排他的（ C ）？

A．serialize

B．transient

C．synchronized

D．static

【解析】synchronized用来对对象加锁，从而使得对对象的访问是排他的。 6．下列说法中，错误的一项是（ A ）。

A．线程一旦创建，则立即自动执行 B．线程创建后需要调用start()方法，将线程置于可运行状态 C．调用线程的start()方法后，线程也不一定立即执行 D．线程处于可运行状态，意味着它可以被调度 【解析】线程创建后需要调用start()方法，将线程置于可运行状态。 7．下列说法中，错误的一项是（ A ）。

A．Thread类中没有定义run()方法

B．可以通过继承Thread类来创建线程 D．可以通过实现Runnable接口创建线程

C．Runnable接口中定义了run()方法 8．Thread类定义在下列哪个包中（ B ）？

A．java.io

B．java.lang

C．java.util

D．java.awt

【解析】Thread类定义在java.lang包中，因此使用时可以不用显式加载。 9．Thread类的常量NORM_PRIORITY代表的优先级是（ C ）。

A．最低优先级

B．最高优先级

C．普通优先级

D．不是优先级

【解析】NORM_PRIORITY代表的优先级是普通优先级。 10．下列关于线程优先级的说法中，错误的一项是（ D ）。

A．MIN_PRIORITY代表最低优先级 C．NORM_PRIORITY代表普通优先级 【解析】代表优先级的常数值越大优先级越高 二、填空题

1．多线程是指程序中同时存在着 多 个执行体，它们按几条不同的执行路线共同工作，独立完成各自的功能而互不干扰。 2．每个Java程序都有一个缺省的主线程，对于Application类型的程序来说，主线程是方法 main() 执行的线程。

3．Java语言使用 Thread 类及其子类的对象来表示线程，新建的线程在它的一个完整的生命周期中通常要经历 新生 、 就绪 、 运

行 、 阻塞 和 死亡 等五种状态。

4．在Java中，创建线程的方法有两种：一种方法是通过创建 Thread 类的子类来实现，另一种方法是通过实现 Runnable 接口的类

来实现。

5．用户可以通过调用Thread类的方法 setPriority() 来修改系统自动设定的线程优先级，使之符合程序的特定需要。 6． start() 方法将启动线程对象，使之从新建状态转入就绪状态并进入就绪队列排队。 29

B．MAX_PRIORITY代表最高优先级

D．代表优先级的常数值越大优先级越低

【解析】Thread类和Runnable接口中都定义了run()方法，而start()方法只有Thread类中进行了定义，而Runnable接口中没有定义。

7．Thread类和Runnable接口中共有的方法是 run() ，只有Thread类中有而Runnable接口中没有的方法是 start() ，因此通过实现Runnable接口创建的线程类要想启动线程，必须在程序中创建 Thread 类的对象。 8．在Java中，实现同步操作的方法是在共享内存变量的方法前加 synchronized 修饰符。

9．线程的优先级是一个在 1 到 10 之间的正整数，数值越大，优先级越 高 ，未设定优先级的线程其优先级取缺省值 5 。 10．Thread类中代表最高优先级的常量是 MAX_PRIORITY ，表示最低优先级的常量是 MIN_PRIORITY 。 三、编程题

1．编写一个有两个线程的程序，第一个线程用来计算2～100000之间的素数的个数，第二个线程用来计算100000～200000之间的素

数的个数，最后输出结果。

【编程分析】本程序主要考察如何实现多线程编程。

第一步：创建线程类CalPrime，在该类中实现素数个数的计算。 第二步：在主类的main()方法中创建线程类对象并启动线程。 【参考程序】

import java.io.*;

public class X9_3_1 {

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

class CalPrime extends Thread{ } 【运行结果】

2~100000之间的素数个数为：9592 100001~200000之间的素数个数为：8392 第8章 一、选择题 30

int from, to, count=0;

public CalPrime(int from, int to){ // 构造方法 }

public void run(){ }

}

System.out.println(from + \之间的素数个数为：\

// 该方法主要计算从from到to之间素数的个数

for(int i=from; i

int m = (int)Math.sqrt(i); boolean isPrime = true; for(int j=2; j<=m; j++){ }

if(isPrime) count++;

if(i%j==0){ }

isPrime = false; break;

this.from = from; this.to = to; }

CalPrime thr1 = new CalPrime(2,100000); CalPrime thr2 = new CalPrime(10000,200000); thr1.start(); thr2.start();

1．下列说法中错误的一项是（ B ）。

A．组件是一个可视化的能与用户在屏幕上交互的对象 B．组件能够独立显示出来 C．组件必须放在某个容器中才能正确显示 D．一个按钮可以是一个组件 【解析】组件不能独立显示，它必须放在某个容器中才能正确显示。 2．进行Java基本GUI设计需要用到的包是（ C ）。

A．java.io

B．java.sql

C．java.awt

D．java.rmi

【解析】进行Java基本GUI设计需要用到的包是java.awt和javax.swing 3．Container是下列哪一个类的子类（ D ）？

A．Graphics

B．Window

C．Applet

D．Component

【解析】Container类是由Component类派生的。 4．java.awt.Frame的父类是（ B ）。

A．java.util.Window

B．java.awt Window C．java.awt Panel

D．java.awt.ScrollPane

【解析】java.awt.Frame的父类java.awt Window。 6．下列叙述中，错误的一项是（ D ）。

A．采用GridLayout布局，容器中的每个组件平均分配容器空间B．采用GridLayout布局，容器中的每个组件形成一个网络状的布局

C．采用GridLayout布局，容器中的组件按照从左到右、从上到下的顺序排列D．采用GridLayout布局，容器大小改变时，每个组件不再平均分配容器空间

【解析】采用GridLayout布局，容器大小改变时，每个组件平均分配容器空间。 7．当单击鼠标或拖动鼠标时，触发的事件是（ D ）。

A．KeyEvent

B．ActionEvent

C．ItemEvent

D．MouseEvent

【解析】对鼠标操作，触发的事件是MouseEvent事件。 9．下列说法中错误的一项是（ D ）。

A．在实际编程中，一般使用的是Component类的子类 B．在实际编程中，一般使用的是Container类的子类 C．Container类是Component类的子类 D．容器中可以放置组件，但是不能够放置容器 【解析】容器中既可以放置组件，也可以放置容器。 12．布局管理器可以管理组件的哪个属性（ A ）？

A．大小

B．颜色

C．名称

D．字体

【解析】布局管理器可以管理组件的位置和大小，而不能管理组件的其他属性。 13．编写AWT图形用户界面的时候，一定要import的语句是（ B ）。

A．import java.awt; B．import java.awt.*; C．import javax.awt D．import javax.swing.*; 【解析】“import java.awt.*;”语句的含义是加载awt包中的所有类，而其他都不是。 14．在类中若要处理ActionEvent事件，则该类需要实现的接口是（ B ）。

A．Runnable

B．ActionListener

C．Serializable

D．Event

【解析】处理ActionEvent事件的类需要实现的接口是ActionListener，它其中包含了actionPerformed()方法。 15．下列不属于java.awt包中的基本概念的一项是（ C ）。

A．容器

B．组件

C．线程

D．布局管理器

【解析】线程不属于java.awt包中的基本概念的一项，其他三个都是。 17．JPanel的默认布局管理器是（ C ）。

A．BorderLayout

B．GridLayout

C．FlowLayout

D．CardLayout

【解析】Panel、JPanel和Applet的默认布局管理器都是FlowLayout。 18．下列说法中错误的是（ B ）。

A．在Windows系统下，Frame窗口是有标题、边框的 B．Frame的对象实例化后，没有大小，但是可以看到 C．通过调用Frame的setSize()方法来设定窗口的大小 D．通过调用Frame的setVisible(true)方法来设置窗口为可见

【解析】Frame的对象实例化后，没有大小，也不能看到，只有通过调用Frame的setSize()和setVisible(true)方法才能设定窗口的大小和可见性。

19．下列说法中错误的是（ D ）。 31

A．同一个对象可以监听一个事件源上多个不同的事件 B．一个类可以实现多个监听器接口 C．一个类中可以同时出现事件源和事件处理者 D．一个类只能实现一个监听器接口 【解析】一个类可以实现多个监听器接口，从而实现对多个事件的监听。 20．下列选项中不属于容器的一项是（ ）。

A．Window 二、填空题

1．Java编程语言是一种跨平台的编程语言，在编写图形用户界面方面，也要支持 跨平台 功能。 2．Java的图形用户界面技术经历了两个发展阶段，分别通过提供 awt 开发包和 swing 开发包来体现。

3．在进行界面设计的时候，只要掌握好AWT和Swing的三点思路，就能编写出较好的图形用户界面：首先是 界面中的组件如何放置 ，其次是 如何让组件响应用户的操作 ，第三是 掌握每种组件的显式效果和响应用户操作 。

4．java.awt包提供了基本的java程序的GUI设计工具，主要包括下述三个概念，它们分别是： 组件 、 容器 和 布局管理器 。 5．组件不能独立地显示出来，必须将组件放在一定的 容器 中才可以显示出来。

6．容器本身也是一个 组件 ，具有组件的所有性质，另外还具有放置其他 组件 和 容器 的功能。 7．容器中的布局管理器负责各个组件的 位置 和 大小 ，因此用户无法在这种情况下设置组件的这些属性。 8．如果用户确实需要亲自设置组件大小或位置，则应取消该容器的布局管理器，方法为 setLayout(null) 。 9．所有的组件都可以通过 add() 方法向容器中添加组件。 10．有3种类型的容器： Window 、 Panel 、 ScrollPane 。

11．FlowLayout类是 java.lang.Object 直接子类。其布局策略是：将容器中的组件按照加入的先后顺序从 左 向 右 排列，当一行排

满之后就转到下一行继续从 左 向 右 排列，每一行中的组件都 居中 排列。它是 Panel 和 Applet 缺省使用的布局编辑策略。 12．对于一个原本不使用FlowLayout布局编辑器的容器，若需要将其布局策略改为FlowLayout，可以使用 setLayout(new FlowLayout()) 方法。

13．BorderLayout类的布局策略是：把容器内的空间划分为 东 、 西 、 南 、 北 、 中

五个区域，它们分别用字符串常量 East 、 West 、 South 、 North 、 Center 表示。 15．在事件处理的过程中，主要涉及3类对象： 事件 、 事件源 和 事件处理者 。

18．标准组件是由 容器 和 基本组件 构成，容器是能够容纳其他组件的对象，而基本组件是放置在容器中而不能在其内部存放

其他组件的对象。

19．按钮可以引发 ActionEvent 事件，TextField可产生 TextEvent 和 ActionEvent 事件，下拉列表可产生 ItemEvent 项目事件。当

用户单击复选框使其选中状态发生变化时就会引发 ItemEvent 类代表的选择事件。

20．ActionEvent事件类包含 ACTION_PERFOMED 事件，该事件通过 ActionListener 接口进行监听，通过调用 addActionListener()

方法将事件源注册到监听器，通过调用 actionPerformed(ActionEvent e) 方法实现监听后的动作，通过调用 getSource()方法 可以获得发生事件的事件源对象，调用 getActionCommand() 方法可以获取引发事件动作的命令名。

29．在Swing中完全可以使用 java.awt.event 包中的各种类进行事件处理，同时它也可以使用 javax.swing.event 包中的类处理事件，而AWT则只能使用 java.awt.event 包中的各种类进行事件处理。 三、编程题

2．创建一个Frame类型窗口，采用GridLayout布局，在窗口中创建一个计算器的界面。 【编程分析】本程序主要考察布局管理问题。

第一步：创建一个主类，其中定义两个面板，一个文本框，一个二维按钮数组，一个二维字符串数组。一个构造方法、一个main()方法。

第二步：在构造方法中创建控件，实现布局。 【参考程序】

import java.io.*; import java.awt.*;

public class X10_3_2 extends Frame{ Panel pn1,pn2; TextField tf; 32

// 定义两个面板 // 定义文本框控件

B．Panel

C．FlowLayout

D．ScrollPane

【解析】FlowLayout类属于布局管理器，而不属于容器。

Button[][] bt = new Button[4][6]; // 定义按钮对象二维数组

String[][] str = {{\

{\

public static void main(String[] args)throws IOException{ } 【运行结果】

}

public X10_3_2(){ }

pn1 = new Panel(); pn2 = new Panel(); tf = new TextField(35); pn1.add(tf);

pn2.setLayout(new GridLayout(4,6)); // 设置pn2面板的布局 for(int i=0; i<4; i++){ // 创建24个按钮控件并添加到pn2面板中 }

for(int j=0; j<6; j++){ }

// 将pn1面板添加到窗口北面 //将pn2面板添加到窗口中间

bt[i][j] = new Button(str[i][j]); pn2.add(bt[i][j]);

// 创建文本框

// 创建面板

new X10_3_2();

add(pn1,BorderLayout.NORTH); add(pn2,BorderLayout.CENTER); this.setSize(300,250); this.setVisible(true);

this.setTitle(\// 设置窗口标题

// 设置窗口大小 // 显示窗口

5．编写一个测试计算是否正确的程序，窗口中包含3个按钮、3个单行文本输入区、一个下拉列表框，当单击第1个按钮时在第1个单行文本输入区中产生一个随机数，当单击第2个按钮时在第2个单行文本输入区中产生一个随机数，在下拉列表框中选择一种运算符，如+、-、*、/等，然后单击第3个按钮，将计算结果显示在第3个单行文本输入区中。

【编程分析】本程序主要考察按钮、文本框、下拉列表框的应用以及随机数的产生和对ActionEvent时间的处理方法。

第一步：创建一个RandomFrame类，该类继承Frame类，实现ActionListener接口。 第二步：在RandomFrame类中定义各种需要的组件及容器，设计好布局，并实现相应功能。 第三步：在主类的main()方法中创建RandomFrame类的对象，从而实现相应的功能。 【参考程序】

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

public class X10_3_5 {

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

class RandomFrame extends Frame implements ActionListener{ Button[] bt = new Button[3]; TextField[] tf = new TextField[3]; String[] item = {\ Choice choice; Panel pn1, pn2; double d1, d2, d3; RandomFrame(){ }

public void actionPerformed(ActionEvent e){ 34

if(e.getSource() == bt[0]){

int i;

for(i=0; i<3; i++){ }

bt[i] = new Button(); bt[i].addActionListener(this); tf[i] = new TextField(12);

new RandomFrame();

bt[0].setLabel(\bt[1].setLabel(\bt[2].setLabel(\choice = new Choice(); for(i=0; i

pn1 = new Panel( ); pn2 = new Panel( ); pn1.add(tf[0]); pn1.add(tf[1]); pn1.add(choice); pn1.add(tf[2]); for(i=0; i<3; i++)

pn2.add(bt[i]);

this.add(pn1, BorderLayout.NORTH); this.add(pn2, BorderLayout.SOUTH); this.setTitle(\

this.addWindowListener(new WindowAdapter(){ } );

this.setSize(400,150); this.setVisible(true);

public void windowClosing(WindowEvent e){ }

System.exit(1);

choice.addItem(item[i]);

} }

}

d1 = (int)(90 * Math.random() )+10; tf[0].setText(String.valueOf(d1) );

if(e.getSource() == bt[1]){ }

if(e.getSource() == bt[2]){ }

int index = choice.getSelectedIndex(); switch (index){ }

tf[2].setText(String.valueOf(d3) );

case 0: d3 = d1 + d2; break; case 1: d3 = d1 - d2; break; case 2: d3 = d1 * d2; break; case 3: d3 = d1 / d2; break; case 4: d3 = d1 % d2; break; d2= (int)(90 * Math.random() )+10; tf[1].setText(String.valueOf(d2) );

【运行结果】

35

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