Java语言程序设计(第2版)第1-6章 课后习题答案

第1章 Java语言概述

选择题

1-1 在下列概念中，Java语言只保留了（B）

A. 运算符重载 B. 方法重载

C. 指针 D. 结构和联合

1-2 下列关于Java语言特性的描述中，错误的是（D）

A. 支持多线程操作

B. Java程序与平台无关

C. Java和程序可以直接访问Internet上的对象

D. 支持单继承和多继承

1-3 下列关于Java Application程序在结构上的特点的中，错误的是（C）

A. Java程序是由一个或多个类组成的

B. 组成Java程序的若干个类可以放在一个文件中，也可以放在多个文件中

C. Java程序的文件名要与某个类名相同

D. 组成Java程序的多个 类中，有且仅有一个主类

1-4 Java程序经过编译后生成 的文件的后缀是（C）

A. .obj B. .exe C. .class D. .java

1-5 下列关于运行字节码文件的命令行参数的描述中，正确的是（A）

A. 第一个命令行参数（紧跟命令字的参数）被存放在args[0]中

B. 第一个命令行参数被存放在args[1]中

C. 命令行的命令字被存放在args[0]中

D.数组args[]的大小与命令行参数的个数无关

判断题

1-1 JavaC++的语言之前问世的。（错）

1-2 Java语言具有较好的安全性和可移植性及与平台无关等特性。（对）

1-3 Java语言中取消了联合的概念，保留了结构概念。（错）

1-4 Java语言中数据类型占内在字节数与平台无关。（对）

1-5 Java语言中可用下标和指针两种方式表示数组元素。（错）

1-6 Java语言的源程序不是编译型的，而是编译解释型的。（对）

1-7 操作系统中进程和线程两个概念是没有区别的。（错）

1-8 Java语言既是面向对象的又是面向网络的高级语言。（对）

1-9 Java程序分为两大类：一类是Application程序，另一类是Applet程序。前者又称

Java应用程序，后者又称为Java小应用程序。（对）

1-10 Java Application程序是由多个文件组成的，其中可以有也可以没有主文件。（错）

1-11 组成Java Application的若干类中，有且仅有一个主类，只有主类中含有主方法

main()。（对）

1-12 Java Application程序中，必有一个主方法main（），该方法有没有参数都可以。（对）

1-13 Java程序中是不区分大小写字母的。（错）

1-14 下述两个命令：javac和java是不同的，编译时用前者，运行时用后者。（对）

1-15 Java程序编译后生成的是字节码文件，其后缀是.exe。（错）

1-16 字节码文件机器是不能直接识别的，它要经过解释器，边解释边执行。（对）

1-17 在Java程序中，使用import语句引入类是在解释器中实现的。（对）

1-18 在运行字节码文件时，使用java命令，一定要给出字节码文件的扩展名.class。（错）

1-19 Java程序中有多个类，编译后只生成一个字节码文件，其名字同主类名。（错）

1-20 Java程序中出现的输出方法println()和print()是完全一致的。（错）

分析程序的输出结果题

1-1 程序Exerl_

import .*;

public class Exerl_1

{

public static void main (String args[ ])

{

("This is a ");

n("strint.")

}

}

该程序的输出结果如下：

This is a string.

1-2 程序Exerl_

Import .*;

Public class Exerl_2

{

Public static void mian(String args[ ])

{

Char ch=" ";

n("Input a character:");

Try{

ch=(char)();

}

Catch(IOException e)

{ }

n("The character is '"+ch+"'");

}

}

该程序的输出结果如下

Input a character:k↙

The character is ‘k’

1-3 程序Exerl_

import .*;

public class Exerl_3

{

Public static void main(String args[ ])

{

String str= " "

n("Input a string:");

Try{

BufferedReader in =new BufferedReader(new InputStreamReader());

str=ne();

}

}

Catch(IOException e )

{ }

n("The string is '"+str+ " " ");

}

1-4 程序Exerl_

import .*

public class Exerl_4

{

public static void main(String args[ ])

{

A a=new A;

a.i=8;

a.d=1.25;

("该程序输出结果如下所示");

n("ti="+a.i+",d="+a.d);

}

}

class A

{

int i;

double d;

void meth(string str)

{

n(str);

}

}

该程序输出结果如下所示

i=8,d=1.25

编程题

1-1编写一个Java Application程序，使该程序运行后输出字符串"Hello!How are you."。

参考程序内容如下

import .*;

public class prol_1

{

public static void main(String args[ ])

{

n("Hello!How are you.");

}

}

1-2 编写一个Java Application程序，使该程序输出显示如下结果：

Var1=10,var2=19.5

Ok!

参考程序内容如下：

import .*;

public class prol_2

{

public static void main(String args[ ])

{

int var1=10;

double var2=19.5;

n("var1="+var1+",var2="+var2);

n("ok!");

}

}

第2章 Java语言语法基础

选择题

2-1 Java语言所用的字符集中字符是 B 位。

A. 8

B. 16

C. 32

D. 64

2-2 下列关于标识符的描述中，正确的是 A 。

A. 标识符中可以使用下划线和美元符

B. 标识符中可以使用连接符和井号符

C. 标识符中大小写字母是无区别的

D. 标识符可选用关键字

2-3 Java语言和各种分隔符中，非法的是 D 。

A. 空白符

B. 分号

C. 逗号

D. 问号

2-4 下列是Java语言中可用的注释，其中错误的是 C 。

A. //

B. /*…*/

C. /**…**/

D. /**…*/

2-5 Java语言中字符型数据的长度是 B 位。

A. 8

B. 16

C. 32

D. 64

2-6 下列描述的两种数据类型的长度不相等的是 A 。

A. 字符型和布尔型

B. 字节型和布尔型

C. 短整型和字符型

D. 整型和单精度浮点型

2-7 下列是Java语言中的复合数据类型，其中错误的是 C 。

A. 数组

B. 接口

C. 枚举

D. 类

2-8 下面是关于Java语言中数据类型的强制转换的描述，其中错误的是 C,D 。

A. 当数据类型从高转换为低时需强制转换

B. 强制转换时使用强制转换去处符，形如（<类型>）

C. 浮点型数据强制转换为整型时，小数部分四舍五入

D. 赋值操作中都要采用强制类型转换

2-9 下列关于常量的描述中，错误的是 B,D 。

A. Java语言的常量有5种

B. 浮点型数12.456是单精度的

C. 布尔型常量只有两个可选值：true和false

D. 字符串常量含有结束符'0 '

2-10 下列关于定义符号常量的描述中，错误的是 A,C 。

A. 定义符号常量使用关键字const

B. 定义符号常量时要赋初值

C. 符号常量既可以定义为类成员，又可在方法中定义

D. 定义符号常量时必须给出数据类型

2-11 下列关于变量的默认值的描述，其中错误的是 B,C 。

A. 定义变量而没有进行初始化时，该变量具有默认值

B. 字符型变量的默认值为换行符

C. 布尔型变量的默认值是true

D. 变量的默认值是可以被改变的

2-12 下列关于变量定义的描述中，正确的是 A,C 。

A. 定义变量时至少应指出变量名字和类型

B. 定义变量时没有给出初值该变量可能是无意义值

C. 定义变量时，同一个类型多个变量间可用逗号分隔

D. 定义变量时必须要给变量初始化

2-13 下列关于变量作用域的描述，错误的是 D 。

A. 在某个作用域定义的变量，仅在该作用域内是可见的，而在该作用域外是不可

见的

B. 在类中定义的变量的作用域在该类中的方法内可以使用

C. 在方法中定义 的变量的作用域仅在该方法体内

D. 在方法中作用域可嵌套，在嵌套的作用域中可以定义同名变量

2-14 下列关于增1（++）减1（--）1运算符的描述中，正确的是 A,B 。

A. 增1 减1运算符都是单目运算符

B. 增1 减1运算符都具有前缀运算和后缀运算

C. 增1 减1运算符不会改变变量的值

D. 增1 减1运算符前缀运算和后缀运算后表达式值是相同的

2-15 关于运算符优先级的描述中，错误的是 D 。

A. 在表达式中，优先级高的运算符先进行计算

B. 赋值运算符优先级最高

C. 单目运算符优先级高于双目和三目运算符

D. 逻辑运算符优先级高于逻辑位运算符

2-16 下列关于表达式的描述中，正确的是 A,C 。

A. 任何表达式都有确定的值和类型

B. 算数表达式的类型由第一个操作数的类型决定

C. 逻辑表达式的操作数是逻辑型的

D. 赋值表达式的类型取决于右值表达式的类型

2-17 下列表达式中，非法的是 B,C 。

int a=5,b=6;double c=1.1,d=2.2

A. a+c+++d

B. (a+c)- -

C. c<

D. a!=b?c:d

2-18 下列关于条件语句的描述中，错误的是 A,C 。

A. If语句可以有多个else子句和else if子句

B. If语句中可以没有else子句和else if子句

C. If语句中的〈条件〉可以使用任何表达式

D. If语句的if体、else体内可以有循环语句

2-19 下列关于开关语句的描述中，错误的是 B,C,D 。

A. 开关语句中，default子句可以省略

B. 开关语句中，case子句的〈语句序列〉中一定含有break语句

C. 开关语句中，case 子句和default子句都可以有多个

D. 退出开关语句的唯一条件是执行break语句

2-20 下列关于循环语句的描述中，错误的是 B,D 。

A. 任何一种循环体内都可以包含一种循环语句

B. 循环体可以是空语句，也可以是空

C. 循环体内可以出现多个break语句

D. 循环语句中，循环体至少被执行一次

2-21 下列循环语句的循环次数是 D 。

int i=5;

do{

n(i--);

i--;

}while(i!=0);

A. 0

B. 1

C. 5

D. 无限

2-22 下列循环语句中，循环体被执行的次数为 D 。

for (int i=0,j=0;(j!=18)||(i<4);i++)

A. 3

B. 4

C. 不确定

D. 无限

2-23 下列关于Java语言的数组描述中，错误的是 D 。

A. 数组的长度通常用length来表示

B. 数组下标从0开始

C. 数组元素是按顺序存放在内在的

D. 数组在赋初值和赋值时都不判界

2-24 下列关于数组的定义形式，错误的是 A,C,D 。

A. int[]a;a=new int;

B. char b[];b=new char[80]

C. int[]c=new char[10]

D. int[]d[3]=new int[2][]

2-25 下列关于字符串的描述中，错误的是 B 。

A. Java语言中，字符串分为字符串常量和字符串变量两种

B. 两种不同的字符串都String类的对象

C. Java语言中不再使用字符数组存放字符串

D. Java Application程序的main()和参数args[]是一个String类的对象数组，用它可

存放若干个命令行参数

判断题

2-1 Java语言标识符中可以使用美元符。（对）

2-2 Java语言标识符中大小写字母是没有区别的。（错）

2-3 分号（；）、逗号（，）和冒号（：）都可作为Java语言中的分隔符。（对）

2-4 文档注释符/**…*/是Java语言特有的注释符。（对）

2-5 Java语言的基础数据类型有4种：整型、浮点型、字符型和布尔型。（对）

2-6 Java语言的复合数据类型有3种：数组、类和包。（错）

2-7 Java语言中，字节型与字符型是一样的。（错）

2-8 Java语言是一种强类型语言，数据类型转换有两种：隐含转换和强制转换（对）

2-9 数据由高类型转换到低类型时，采用强制转换，数据精度要受到损失。（对）

2-10 布尔型常量可以自动转换为短整型常量 。（错）

2-11 Java语言使用的是Unicode字符集，每个字符在内在中占8位。（错）

2-12 Java语言的字符串中不隐含结束符。（对）

2-13 Java语言中定义符号常量使用final关键字。（对）

2-14 Java语言中不同数据类型的长度是固定的，不随机器硬件不同而改变。（对）

2-15 Java语言中只有无符号的字符型。（对）

2-16 字符型变量中只存放一个字符。（对）

2-17 定义变量时必须进行初始化，否则变量具有无意义的值。（错）

2-18 若定义变量时不进行初始化，则该变量一定具有默认值。（错）

2-19 Java语言中，变量出现的位置只有一种，即为类体内定义的成员变量。（错）

2-20 Java语言规定在的程序块中不允许定义同名变量。（对）

2-21 求余运算符%可用于整数和浮点数。（错）

2-22 关系运算符组成的表达式是逻辑表达式。（错）

2-23 逻辑运算符&和&&是没有区别的，都具有逻辑与的功能。（错）

2-24 运算符& 是逻辑与运算符还是按位与运算符取决于操作数的类型。（对）

2-25 运算符“>>”和“>>>”都是右移运算符，其区别在于对向右移出的位是舍弃还是保

留。（错）

2-26 赋值运算符组成的赋值表达式中，通常将右边表达式的类型转换为左边变量的类

型后再赋值。（对）

2-27 三目运算符的3个操作数中，第一个操作数的类型必须是逻辑型的（对）

2-28 强制类型转换运算符的功能是将一个表达式的类型转换为所指定的类型。（对）

2-29 对象运算符instanceof是一个单目运算符，其表达式的值的类的对象。（错）

2-30 内存分配运算符new可以为创建的数组分配内存空间，但不能为创建的变量分配

空间。

2-31 运算符的优先级中，最低的是三目运算符。（错）

2-32 运算符的结合性中，除了三目运算符是自右向左外，其余都是自左向右。（错）

2-33 关系表达式和逻辑表达式的值都是布尔型的。（对）

2-34 赋值表达式的值不能是逻辑型的。（错）

2-35 条件表达式的类型总是“？”和“：”之间的操作数的类型。（错）

2-36 块语句可能嵌套，外层块语句定义的变量在内层块语句中是可见的（对）

2-37 条件自勉中的<条件>表达式可以是任何表达式。（错）

2-38 在条件语句的嵌套结构中，一个if子句最多有一个else子句与它配对，而且一定

是距离它最近的。（对）

2-39 开关语句中，case子句后面的<语句序列>可以是块语句。（对）、

2-40 循环语句中，<条件>表达式必须是逻辑型表达式。（对）

2-41 在Java语言中，break语句不能作用在<标号名>的左边。（错）

2-42 Java语言中，数组在静态和动态赋值时都判越界。（对）

2-43 说明或声明数组时不分配内存大小，创建数组时分配内存大小。（对）

2-44 基本数据类型的数组在创建时系统将指定默认值。（对）

2-45 数组在定义时可以进行初始化，使用初始值表。（对）

2-46 Java语言中数组元素只有下标表示，没有指针表示。（对）

2-47 创建数组时，系统自动将数组元素个数存放在length变量中，可供用户对数组操

作时使用。（对）

2-48 字符串可分为字符串常量和字符串变量两种，它们都是对象。（对）

2-49 Java语言中不使用字符数组存放字符串（对）

2-50 下列创建字符串s的方法是错误的。（对）

char ch[]={'m',m','n','n'};

char s[]=new char(ch);

计算表达式的值，上机验证其结果题

2-1 已知:int a=3,b=5;

求下列表达式的值：

（1） （a+b）%b

（2） b>>a

（3） -b>>>a

（4） A&b

（5） ++a-b++

答案：（1）3 （2）0

2-1 已知：double x=1.5,y=2.8;

求下列表达式的值：

（3）53670911 （4）1 （5）-1

（1） x++>y—

（2） x+4/5

（3） 2*x==y

（4） y/6*6

（5） y+=x-=1

答案（1）false (2)1.5 (3)false

2-3 已知:Boolean b1=true, b2=false; int a=6;

求值：

（1） b1&b2

（2） !b1&&b2||b2

（3） b2&b1|!b2

（4） b1!=b2

（5） !(a>6)&a6|b2=true)

答案：（1）false （2）false

2-4 已知：int a[]={3,5,7,9};

(4)2.8 (5)3.3

（3）true （4）false （5）true

求值：

a[0]+a[1]

a[3]=6

a[2]*a[3]>4*a[3]

(a[0]+=a[1])+ ++a[2]

for(int i=1;i<4;i++)

a[0]+=a[i];

答案：（1）8 （2）6 （3）true （4）16

分析程序输出结果题

2-1 Exer2_程序

public class Exer2_1

{

public static void main(String args[])

{

int i=3;

char c='p';

float f=3.5f;

double d=32.56;

short s=25;

booleab=true;

string st="new";

n("i+s="+(i+s));

n("d+f="=(d+f));

n("st+"year"="+st+"year");

n("!b||b="+(!b||b));

n("b?i:d="+(b?i:d));

}

}

输出结果如下：

i+s=28

d+f=36.06

st+"year"=new year

c+2=r

!b||b=true

b?i:d=3.0

2-2 Exer2_程序

public class Exer2_2

{

public static void main(String args[])

{

int suma=0,sumb=0;

for(int a=0,b=0;a<5;a++,b++)

{

suma+=a;

（1）

（2）

（3）

（4）

（5）

（5）24

sumb+=b;

}

n("suma="+suma+",sumb="+sumb)

}

}

输出结果如下：

suma=10,sumb=60

2-3 Exer2_程序

public class Exer2_3

{

public static void main(String args[])

{

int i,j;

First_Loop:

for(i=1;i<50;i++)

{

for(j=2;j

if(i%j)==0

continue First_Loop;

n(i);

}

}

}

输出结果如下：

1

2

3

5

7

11

13

17

19

23

29

31

37

41

43

47

2-4 Exer2_程序

public class Exer2_4

{

public static void main(String args[])

{

char ch='B';

switch(ch)

{

case'A':n("5"):break;

case'B':n("4"):break;

case'C':n("3"):break;

default:n("0");

}

}

}

输出结果如下：

4

2-5 Exer2_程序

public class Exer2_5

{

public static void main(String args[])

{

int a=3,b=5;

if(a==3)

if(b==1)

a++;

else

b++;

n(a+","+b);

int x=1,y=4;

if(x==2)

{

if(y==4)

x++;

}

else

y++;

n(x+","+y);

}

}

输出结果如下：

3,5

1,5

2-6 Exer2_程序

public class Exer2_6

{

public static void main(String args[])

{

int i;

for(i=1;i<10;i++)

{

if(i>2)

n("AB");

else

n("BA");

if(i==5)

break;

}

n("i="+i);

}

}

输出结果如下：

BA

BA

AB

AB

AB

i=5

2-7 Exer2_程序

public class Exer2_7

{

public static void main(String args[])

{

long j1=1,j2=1;

for(int i=5;i>=1;i--)

j1*=i;

for(int i=4;i>=1;i--)

j2*=i;

n("5!+4!"+(j1+j2));

}

}

输出结果如下：

5!

4!=144

2-8 Exer2_程序

public class Exer2_8

{

public static void main(String args[])

{

String s1="123456";

char ch[]={'4','5','6','7','8'};

double d[];

d=new double[5];

d[0]=1.2f;d[1]=2.3f;d[2]=3.4f;d[3]=4.5f;d[4]=5.6f;

String s2[]={"ab","cd","ef"};

int[]a[]={{1,2,3},{4,5,6},{7,8,9}};

n("s1="+s1);

for(ing i=0;i<5;i++)

(ch[i]+",");

n();

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

d[0]+=d[i];

n("d[0]="+d[0]);

n(s2[0]+";"+s2[1]+";"+s2[2]);

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

{

n();

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

(a[i][j])+" ";

}

}

}

输出结果如下：

s1=123456

4,5,6.7.8

d[0]=18.216

ab;cd;ef

1 2 3

4 5 6

7 8 9

2-9 Exer2_程序运行时命令行带有参数。运行格式如下：

C:Exer2_9 51 100↙

程序Exer2_内容如下：

public class Exer2_8

{

public static void main(String args[])

{

int sum=0;

ing i=nt(args[0]);

int n=nt(args[1]);

for(;i<=n;i++)

sum=+=i;

n("sum="+sum);

}

}

输出结果如下：

sum=3775

2-10 Exer2_程序

public class Exer2_8

{

public static void main(String args[])

｛

A:

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

{

for(ing j=0;j<8;j++)

{

("*");

n();

continue A;

}

}

}

}

输出结果如下：

*

*

*

*

*

编程题

2-11 按下列要求写出Java语言的语句。

（1） 定义一个double型变量d，并赋初值为2.5。

该语句如下：

Double d=2.5;

（2） 在屏幕上输出显示（1）中所定义的变量d的值。

该语句如下：

n("d="+d);

（3） 定义一个字符型一维数组ch它的大小为10。

该语句如下：

char ch[]=new char[10];

（4） 定义一个字符串常量s1，其字符串为“abc”

String s1="abc";

（5） 定义一个boolean型变量b,赋初值为true。

boolean b=true

（6） 在屏幕上输出显示26个大写字母。

实现该功能的程序段如下：

for(char ch='a';ch<='z';ch++)

(ch)

n();

（7） 将代数式s=a

2

+2ab+b

2

写成一个赋值表达式语句。

该语句如下：

s=a*a+2*a*b+b*b

（8） a,b和c是3个int型变量，用条件表达式写出a>b时，c值为a，否则c值为b。

int a,b,c;

┊

if(a>b)

c=a;

else

c=b;

（9） 用for循环语句实现下述循环：循环变量m为100，每次m循环减10；当m

等于50时退出循环，循环体为空语句。

for(int m=100;m==50;m-=10)

{ }

（10） 使用带标号名的break语句，在双重for循环自勉结构中，一次从内层循环跳

出外层循环。

该功能程序段如下：

┊

F:for(ing i=…)

{

┊

for(ing j=…)

{

┊

break F;

}

┊

}

┊

2-12 编程求出一个一维int型数组的元素最大值、最小值、平均值和所有元素之和。

程序内容如下：

import .*;

public class pro2_1

{

public static void main(String args[])

{

int a[]={23,76,45,21,63,90,46,83};

int max,min,sum;

max=min=a[0];

for(int i=1;i<8;i++)

if(max

max=a[i];

for(int i=1;i<8;i++)

if(min>a[i])

min=a[i];

for(int i=1;i<8;i++)

sum+=a[i];

n("max="+max+",min="+min+",ave="+sum/8+",sum="+su

m);

}

}

运行该程序后，输出结果如下：

Max=90,min=21,ave=53,sum=424

2-3 编程将一个浮点型数的整数部分和小数分别输出显示。

import .*;

public class pro2_2

{

public static void main(String args[])

{

double d=23.56dl;

d1=d;

int n=0;

while(true)

{

d--;

if(d<0)

break;

n++

}

n("integer="+n+",decimal="+(d1-n));

}

}

运行该程序后，输出结果请读者自己分析

2-4 编程生成Fibonacci数列，该数列定义为：

f

1

=f

2

=1, f

n

=f

n-1

+f

n-2

(n≥3)

程序内容如下：

import .*;

public class pro2_3

{

public static void main(String args[])

{

int f1,f2;

f1=f2=1

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

{

(f1+" "+f2+" ");

f1+=f2;

f2+=f1;

}

n()

}

}

这里假定生成Fiblnacci数列的前20项，可根据需要生成若干项。运行该程序后的

输出结果如下：

1 1 2 3 5 8 13 21 34 55

2-5 编程求出自然数101~205中的所有素数。

程序内容如下

import .*;

public class pro2_4

{

public static void main(String args[])

{

int n=0;

boolean prime=false;

for(int i=101;i<=205;i+=2)

{

prime=true;

for(int j=2;j

if(j%j==0)

{

prime=false;

break;

}

if(prime)

{

(i+" ");

n++;

}

if(n%8==0)

n();

}

}

}

2-6 使用switch语句根据考试成绩等级输出百分制的分数段。规定如下：

A. 85~100

B. 70~84

C. 60~69

D. <60

假定85~100分为A，70~84为B，60~69分为C,<60分为D。

程序内容如下：

import .*;

public class pro2_5

{

public static void main(String args[])

{

int a=f(args[0].intValue());

int n=a/5;

if(a<60)

n=11;

switch(n)

{

case 20:case 19:case 18:case 17:

n("A");break;

case 16:case 15:case 14:

n("B");break;

case 13:case 12:

n("C");break;

case 11:

n("D");

}

}

}

输入的分数是通过命令行参数来实现的。假定命令参数为73时，运行该程序输出

结果如下：

B

2-7 百鸡百钱问题。公鸡每只3无，母鸡每只5无，小鸡3只一元，用100元买100

只鸡，公鸡、母鸡、小鸡应各买多少？

程序内容如下：

import .*;

public class pro2_6

{

public static void main(String args[])

{

for(int a=1;a<34;a++)

for(int b=1;b<21;b++)

if(3*a+5*b+(100-a-b)/3==100 && (100-a-b)%3==0)

n("公鸡="+a+"，母鸡="+b+"，小鸡="+(100-a-b));

}

}

运行该程序后输出结果如下：

公鸡=4，母鸡=12，小鸡=84

公鸡=11，母鸡=8，小鸡=81

公鸡=18，母鸡=4，小鸡=78

2-8 编程输出如图所示的图形

*

* * *

* * * * *

* * * * * * *

* * * * * * * *

程序内容如下：

import .*;

public class pro2_7

{

public static void main(String args[])

{

for(int i=1;i

{

for(int j=1;j

if(j<=9-i)

(" ")

else

("*");

n();

}

}

}

*

第3章 Java语言面向对象的特征

选择题

3-1 下列对封装性的描述中，错误的是( B ).

A.封装体包含了属性和行为

B.封装体中的属性和行为的访问权限是相同的

C.被封装的某些信息在封装体外是不可见的

D.封装使得抽象的数据类型提高了可重用性

3-2 下列关于继承性的描述中，错误的是（C）

A.一个类可以同时生成多个子类

B.子类继承了父类的所有成员

C. Java语言支持单重继承和多重继承

D. Java语言通过接口可使子类使用多个父类的成员

3-3 下列对多态性的描述中，错误的是（A）

A. Java语言允许运算符重载

B. Java语言允许方法重载

C. Java语言允许变量覆盖

D.多态性提高了程序的抽象性和简洁性

3-4 在类的修饰符中，规定只能被同一包类所使用的修饰符是（B）

A. public B.默认 C. final D. abstract

3-5 在成员变量的修饰符中，规定只允许该类自身访问的修饰符是（A）

A. private B. public C.默认 D. protected

3-6 在成员方法的访问控制修饰符中，规定访问权限包含该类自身，同包的其他类和其他包

的该类子类的修饰符是（D）

A. public B. private C.默认 D. protected

3-7 下列关于构造方法的特点的描述中，错误的是（A）

A.不可重载 B.方法名同类名 C.无返回类型 D.系统自动调用

3-8 下列关于静态方法的特点的描述中，错误的是（D）

A.在类体内说明静态方法使用关键字 static

B.静态方法只能处理静态变量或调用静态方法

C.静态方法不占用对象的内存空间，非静态方法占用对象的内存空间

D.静态方法只能用类名调用

3-9 下列对静态初始化器的描述中，错误的是（D）

A.静态初始化器是用来对类进行初始化的，而不是对某个对象初始化

B.静态初始化器是由关键字 static 和一对花括号组成的语句组

C.静态初始化器不同于构造方法，它不是方法

D.静态初始化器在产生新对象时，是由系统自动调用的

3-10 下列关于抽象类的描述中，错误的是（C）

A.抽象类是用修饰符 abstract 说明的

B.抽象类是不可以定义对象的

C.抽象类是不可以有构造方法的

D.抽象类通常要有它的子类

3-11 下列关于类的继承性的描述中，错误的是（D）

A.继承是在已有类的基础上生成新类的一种方法

B.子类继承父类的所有成员

C. Java 语言要求一个子类只有一个父类

D.父类中成员的访问权限在子类中将被改变

3-12 下列关于子类继承父类的成员的描述中，错误的是（A）

A.子类中继承父类中的所有成员都可以直接访问

B.子类中定义有与父类同名变量时，子类继承父类的操作中，使用继承父类的变量；子

类执行自己的操作中，使用自己定义的变量

C.当子类中出现成员方法头与父类方法头相同的方法时，子类成员方法覆盖父类中的成

员方法

D.方法重载是编译时处理的，而方法覆盖是在运行时处理的

3-13 下列关于接口的描述中，错误的是（B）

A.接口实际上是由变量和抽象方法构成的特殊类

B.一个类只允许继承一个接口

C.定义接口使用的关键字是 interface

D.在继承接口的类中通常要给出接口中定义的抽象方法的具体实现

3-14 下列关于包的描述中，错误的是（A）

A.包是一种特殊的类 B.包是若干个类的集合

C.包是使用 package 语句创建的 D.包有有包名包和无名包两种

3-15 下列常用包中，存放用户图形界面类库的包是（A）

A. B. C.

3-16 下列是系统提供的常用的类，所有类的父类的类是（B）

A. Math B. Object C. System D. String

判断题

3-1 类是一种类型，也是对象的模板。（对）

3-2 Java语言只支持单重继承，不支持多重继承。（对）

3-3 类中说明的方法可以定义在类体外。（错）

3-4 class 不是定义类的唯一关键字。（错）

3-5 某类的对象可以作为另一个类的成员。（对）

3-6 在类体内说明成员变量时不允许赋初值。（错）

3-7 最终变量就是Java 语言中的符号常量。（对）

3-8 静态变量的引用只能使用对象。（错）

3-9 静态方法只能处理静态变量。（对）

3-10 抽象方法是一种只有说明而无具体实现的方法。（对）

3-11 最终方法是不能被当前子类重新定义的方法。（对）

3-12 Java语言中，方法调用一律都是传址的引用调用。（错）

3-13 非静态方法中不能引用静态变量。（错）

3-14 静态初始化器是在构造方法被自动调用之前运行的。（对）

3-15 抽象方法仅有方法头，而无方法体。（对）

3-16 抽象方法一定出现在抽象类中。（对）

3-17 最终类，最终方法和最终变量的修饰符都用final 。（对）

3-18 创建对象时系统将调用适当的构造方法给对象初始化。（对）

3-19 使用运算符new 创建对象时，赋给对象的值实际上是一个地址值。（对）

3-20 使用构造方法只能给非静态成员变量赋初值。（对）

3-21 创建对象时，该对象占用的内存空间除了非静态的成员变量外，还有非静态的成员方

法。（对）

3-22 Java 语言中，对象成员的表示只使用运算符 “.”。（对）

3-23 Java 语言中，对象赋值实际上是同一个对象具有两个不同的名字，因为他们都有同

一个地址值。（对）

3-24 对象可作方法参数，对象数组不能作方法参数。（错）

3-25 Java语言中，所创建的子类都应有一个父类。（对）

3-26 Java语言中，类的继承是可以传递的。（对）

3-27 Java语言中，构造方法是可以继承的。（错）

3-28 子类中构造方法应包含自身类的构造方法和直接父类的构造方法。（对）

3-29 调用this 或 super 的构造方法的语句必须放在第一条语句。（对）

3-30 子类对象可以直接赋值给父类对象；而父类对象不可以赋值给子类对象。（错）

3-31 子类中所继承父类的成员都可以在子类中访问。（错）

3-32 成员方法的重载和覆盖是一回事。（错）

3-33 一个类可以实现多个接口。接口可以实现“多重继承”。（对）

3-34 实现接口的类不能是抽象类。（错）

填空题

3-1 对象具有3大要素，它们分别是（状态），（行为），（标志）。这3大要素分别用（变量），

（方法），（对象名）表示。

3-2 定义类时，通常要使用的关键字有（class），（extends），（implements）。

3-3 成员变量的定义格式如下：（[<修饰符>]）<变量类型><变量名>（=<初值>）；

3-4 成员变量的非访问控制修饰符有（static），（final），（volatile）。

3-5 在成员方法的定义中可省略的部分有（修饰符），（参数表），（异常类名列表）。

3-6 Java 语言中，重载方法的选择是在（编译）时进行的，系统根据（参数个数），（参数类

型），（参数顺序）寻找匹配方法。

3-7 没有子类的类称为（最终类），不能被子类重载的方法称为（最终方法），不能被改变值

的量称为常量，又称为（最终变量）。

3-8 创建一个对象时，通常要包含3项内容：（说明对象），给对象分配空间，（对象初始化）。

3-9 系统规定int型变量默认值为（0），浮点型变量的默认值为（0.0），布尔型变量的默认

值为（false）。

3-10 Java语言中，定义子类时，使用关键字（extends）来给出父类名。如果没有指出父类，

则该类的默认父类为（object类）。

3-11 系统规定：表示当前类的构造方法用（this（）），表示直接父类的构造方法用（super

（））。

3-12 接口中默认的成员变量的修饰符为（final），默认的成员方法的修饰符是（abstract）。

3-13 实现接口中的抽象方法时，必须使用（完全相同）方法头，并且还要用（public）修饰

符。

3-14 包名与子包名之间用（.）分隔。加载包的关键字是（import）。

3-15 字符串类又包含两大类，它们是（String）和（StringBuffer）.

分析程序的输出结果题

3-1 Exer3_

class A

{

int x,y,z,sum;

A(int i,int j,int k)

{

x=i;

y=j;

z=k;

sum=x+y+z;

}

boolean sameA(A al)

{

if((al.x==x)&(al.y==y)&(al.z==z))

return true;

else

return false;

}

boolean sameS(A al)

{

if(==sum)

return true;

else

return false;

}

}

class Exer3_1

{

public static void main(String args[])

{

A a=new A(2,5,8);

A b=new A(2,5,8);

A c=new A(5,8,2);

n(a,sameA(b));

n(a,sameA(c));

n(a,sameA(b));

n(a,sameA(c));

}

}

输出结果如下：

true

false

true

true

3-2 Exer3_

class B

{

void meth(int i)

{n("Int:"+i);}

void meth(double i)

{n("Double:"+i);}

}

class Exer3_2

{

public static void main(String args[])

{

int i=8;

double d=6.8;

short s=10;

float f=5.3f;

byte b=9;

char c='a';

B ob=newB();

(i);

(d);

(s);

((int)f);

(b);

(c);

}

}

输出结果如下：

Int:8

Double: 6.8

Int:10

Int:5

Int:9

Int:97

3-3 Exer3_

class C

{

int c;

C(int a)

{

c=0;

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

c+=i;

}

C(Cb)

{c=b.c;}

}

class Exer3_3

{

public static void main(String args[])

{

C c1=new C(6);

C c2=new C(new C(4));

n("c1:"+c1.c);

n("c2"+c2.c);

}

}

输出结果如下：

c1:21

c2:10

3_4 Exer3_

class D

{

static int d=100;

static int meth()

{

int s=d*10;

return(s);

}

D(int i)

{d=i;}

}

class Exer3_4

{

public static void main(String args[])

{

n(":"+D.d);

D dd=new D(10);

n("d:"+D.d);

n("dd:"+dd.d);

n(":"+());

n(":"+());

n("d:"+D.d);

D.d=500;

n(":"+());

}

}

输出结果如下：

:100

d:10

dd:10

:100

:100

d:10

:5000

3_5 Exer3_

class E

{

double h,w;

void show()

{n("width="+w+",height="+h);}

}

class T extends E

{

double area()

{return w*h;}

}

class Exer3_5

{

public static void main(String args[])

{

T t1=new T();

T t2=new T();

t1.w=8.0;

t1.h=5.0;

t2.w=12.0;

t2.h=16.0;

();

n("t1:area="+());

();

n("t2:area="+());

}

}

输出结果如下：

Width= 8.0 , height=5.0

t1:area=40.0

width=12.0,height=16.0

t2:area=192.0

3-6 Exer3_

class A

{

A()

{n("class A");}

}

class B extends A

{

int b;

B(int i)

(b=i);

}

class C extends B

{

private int c;

C(int i,int j)

{

super(j);

c=i;

}

int return c()

{return c;}

}

class Exer3_6

{

public static void main(String args[])

{

C c=new C(5,18);

n("c:"+c.b* c());

}

}

输出结果如下：

class A

c:90

3-7 Exer3_

class A

{

void show()

{n("class A");}

}

class B extends A

{

void show()

{n("class B");}

}

class C extends B

{

void show()

{n("class C");}

}

class Exer3_7

{

public static void main(String argsp[])

{

A a=new A();

B b=new B();

C c=new C();

A x=new A();

x=a;

();

x=b;

();

x=c;

();

}

}

输出结果如下：

class A

class B

class C

3-8 Exer3_

abstract class Shap

{

private double w,h;

Shap(double i)

{w=h=i;}

Shap(double i,double j)

{w=i,h=j;}

Shap(Shap s)

{

w=s.w;

h=s.h;

}

double getw()

{return w;}

double geth()

{return h;}

abstract double area();

}

class Rest extends Shap

{

Rect(double i)

{super(i);}

Rect(double i,double j)

{super(i,j);}

Rect(Rect r)

{super(r);}

double area()

{return getw()*geth();}

}

class Exer3_8

{

public static void main(String args[])

{

Shap s[]=new Shap[3];

s[0]=new Rect(8.0);

s[1]=new Rect(5.0,6.0);

s[2]=new Rect(new Rect(12.0,4.0));

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

n("s["+i+"]area="+s[i].area());

}

}

输出结果如下：

s[0]area=64.0

s[1]area=30.0

s[2]area=48.0

3-9 (在子目录address下)

package address;

public class addre

{

private String s1,s2,s3;

public addre(String str1,String str2,String str3)

{

s1=str1;

s2=str2;

s3=str3;

}

public void show()

{

(s1);

("t"+s2);

n("t"+s3);

}

}

Exer3_

import address.*;

class Exer3_9

{

public static void main(String args[])

{

addre s[]=new addre[2];

s[0]=new addre("PKU","building 44","room 109");

s[1]=new addre("PKU","building 54","room 209");

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

s[i].show();

}

}

输出结果如下：

PKU building 44 room 109

PKU building 54 room 209

3-10 Exer3_

interface Series

{

int getVal();

}

class R1 implements Series

{

int val;

R1()

{val=0;}

public int getVal()

{

val++

return val;

}

}

class R2 implements Series

{

int val;

R2()

{val=0;}

public int getVal()

{

val+=2;

return val;

}

}

class Exer3_10

{

public static void main(String args[])

{

R1 r1=new R1();

R2 r2=new R2();

Series s;

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

{

s=r1;

n("r1:"+());

s=r2;

n("r2:"+());

}

}

}

输出结果如下：

r1:1

r2:2

r1:2

r2:4

r1:3

r2:6

第四章 Java Applet及其应用

选择题

4-1 Applet类是属于（B）包的。

A. B. C. D.

4-2 下列关于Applet程序的描述中，错误的是（B）。

A．Applet程序的主类必须是Applet类的子类

B．Applet程序的主类中应该有一个main()方法

C．Applet不是完整的独立程序

D．Applet的字节码文件必须嵌套在一个HTML文件中

4-3 下列关于Applet程序的描述中，错误的是（D）。

A．将编辑好的Java源文件，使用javac命令生成字节码文件

B．将字节码文件嵌入HTML文件，并存放在一个WWW服务器中

C．使用浏览器解释HTML文件中的标记

D．使用编译器直接执行嵌套在HTML文件中的字节码文件

4-4 在Applet类的主要方法中，用来实现初始化操作的是（A）。

A．init() B. stop() C. start() D. paint()

4-5 下列关于HTML文件的描述中，错误的是（C）。

A．HTML文件是使用一种超文本标记语言（HTML）书写的文件

B．HTML文件中使用的标记通常是用一对尖括号括起来的，两个标记之间是正文内容

C．HTML文件中没有单独出现的标记

D．HTML中不区分大小写字母

4-6 下列关于向Applet程序传递参数的描述中，错误的是（A）。

A．Applet程序可以通过命令获取外部参数

B．Applet程序可以通过HTML文件获取外部参数

C．使用Applet标记中的PARAM标志来实现

D．Applet程序中使用getParameter()方法读取参数值

4-7 下列关于字体的描述中，错误的是（C）。

A．Font类提供了创建字体对象的方法

B．字体风格（字型）使用了3个静态常量表示

C．表示字型的字体风格只能单独使用，不可以组合

D．字号表示字的大小，用点表示，一个点为1/72英寸

4-8 下列用来获取当前颜色的方法是（A）。

A．getColor() B. setColor() C. getRed() D. Color()

4-9 下列各种绘制矩形的方法中，绘制实心矩形的方法是（A）。

A. fillRect() B. drawRect()

C. clearRect() D. drawRoundRect()

4-10 下列演示图像的描述中，错误的是（D）。

A．使用图像类Image定义图像对象

B．使用方法getImage（）获取图像信息

C．使用方法drawImage（）显示图像

D．不可使用显示图像方法进行缩放

判断题

4-1 Applet程序是通过浏览器中内置的Java解释器来解释执行的。（对）

4-2 Applet程序是以.Java为扩展名的Java语言源程序，该程序经过编译器后便可成为可执

行文件。（错）

4-3 嵌入到HTML文件中的是Applet的源程序。（错）

4-4 运行Applet程序是使用AppletViewer命令运行嵌入了字节码文件的HTML文件，从而

获得运行结果。（对）

4-5 Applet程序中的主类必须是Applet类的子类。（对）

4-6 Applet类是Java语言类库中的一个重要的系统类，它被存放在包中。（错）

4-7 init()方法是用来完成初始化操作的，在Applet程序运行期间只执行一次。（对）

4-8 start()方法被系统自动调用来启动主线程运行。通常在Applet程序被重启动时，该方法

被系统自动调用。（对）

4-9 paint()方法是在需要重画图形界面时被系统自动调用来显示输出结果的。（对）

4-10 stop()方法是用来暂停执行操作的，它与start()方法不同，只被调用一次。（错）

4-11 init()，start()，stop()和destroy()4个方法构成Applet程序的生命周期。（对）

4-12 HTML语言中和是用来表示HTML文件开始和结束的标记。（错）

4-13 HTML中多数标记是成对出现的，也有不成对出现的标记。（对）

4-14 HTML中是区分大小写字母的。（错）

4-15 通过HTML文件中使用的PARAM标记可以向Applet程序传递参数的。（对）

4-16 parseInt()方法的功能是将int型数据转换成String型数据的。（错）

4-17 AWT提供了许多标准的GUI组件和布局管理等类。（对）

4-18 Java语言采用了16位颜色标准，Java的调色板保证128色。（错）

4-19 Graphics类提供了3种绘制文本的方法，其方法名都是drawString()。（对）

4-20 绘制椭圆的方法是drawOval()，使用该方法也可以绘制圆。（对）

分析程序的输出结果题

4-1 Exer4_

import ;

import .*;

public class Exer4_1 extends Applet

{

String str="学习JAVA小程序";

public void paint(Graphics g)

{

ring(str,100,100);

}

}

请读者自编相应的HTML文件

运行该程序之前，编写一个HTML文件，文件名为Exer4_。程序内容如下：

运行时，先将Exer4_文件使用javac命令编译成Exer4_文件，然后，再运

行Exer4_文件，则输出显示如下信息：

学习JAVA小程序

4-2 Exer4_

import ;

import .*;

public class Exer4_2 extends Applet

{

String str1,str2;

public void init()

{

str1=getParameter("name");

str2=getParameter("birthday");

if(str1==null)str1="";

if(str2==null)str2="";

}

public void paint(Graphics g)

{

ring("姓名是"+str1+"出生年月日是"+str2,100,100);

}

}

Exer4_文件内容如下：

运行该程序后，输出如下结果。

姓名是宋小山 出生年月日是 1966年8月8日

4-3 Exer4_

import ;

import .*;

public class Exer4_3 extends Applet

{

String str="您好！";

char ch[]={'H','e','l','l','o'};

byte byt[]={97,98,99,100,101,102};

public void paint(Graphics g)

{

tes(byt,0,5,50,50);

ars(ch,0,3,50,70);

ring(str,50,90);

}

}

运行前编写一个相应的HTML文件，运行输出结果如下：

abcde

Hel

您好！

4-4 Exer4_

import ;

import .*;

public class Exer4_4 extends Applet

{

public void paint(Graphics g)

{

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

drawGraphics(i,g);

}

public void drawGraphics(int n,Graphics g)

{

ect(10,10,300,300);

switch(n)

{

case 0:case 3:

or();

ct(50,50,150,150);

break;

case 1:case 4:

or();

al(40,40,160,160);

break;

case 2:case5:

or();

ct(50,50,200,200);

break;

}

try{

(1500);

}

catch(InterruptedException e)

{(0);}

}

}

运行该程序前编写相应的HTML文件，运行后在屏幕上显示变化的图形：先显示红色的正

方形，再显示蓝色圆，最后显示用绿色填充的方块，并且重复一遍。

编程题

4-1编写Applet程序，在指定大小的屏幕界面上使用不同颜色绘制如下图形：

（1）直径为100像素点的圆；

（2）两个半轴长分别为50像素点和100像素点的椭圆；

（3）长和宽都为150像素点的矩形；

（4）使用红色填充（3）中的矩形；

（5）大小由读者指定的填充圆弧。

编写的Java小程序名为pro4_，程序内容如下：

import ;

import .*;

public class pro4_1 extends Applet

{

public void paint(Graphics g)

{

ect(10,10,300,300);

or();

al(40,40,100,100);

or();

al(160,40,50,100);

or();

ect(50,150,150,150);

or();

ct(50,150,150,150);

or();

c(220,50,180,125,30,120);

}

}

相应的HTML文件内容如下：

4-2编写Applet程序，选择3种不同的字体写出字符串“I Love Beijing！”。

编写的Applet小程序文件名为pro4_,程序内容如下：

import ;

import .*;

public class pro4_2 extends Applet

{

Font fnt1=new Font("Serif",,25);

Font fnt2=new Font("Monospaced",,40);

Font fnt3=new Font("Helvetica",,40);

public void paint(Graphics g)

{

String str="I Love Beijing!";

t(fnt1);

or();

ring(str,30,40);

t(fnt2);

or();

ring(str,30,80);

t(fnt3);

or();

ring(str,30,120);

}

}

相应的HTML文件读者自编。

4-3 编写Applet程序，在一个椭圆内填写一个字符串。椭圆大小和位置以及字符串内容和

字体都由读者自定。

编写的Applet小程序的文件名为pro4_,程序内容如下：

import ;

import .*;

public class pro4_3 extends Applet

{

public void paint(Graphics g)

{

int x0=30,y0=35,W=300,H=100;

or();

al(x0,y0,W,H);

or();

t(new Font("Helvetica",,45));

ring("北京，您好！",50,100);

}

}

相应的HTML文件由读者自编。

第5章 图形用户界面设计

选择题

5-1 下列关于容器的描述中，错误的是 （D）

A．容器是由若干个组建和容器组成的

B．容器是对图形界面中界面元素的一种管理

C．容器是一种对指定宽和高的矩形范围

D．容器都是可以独立的窗口

5-2 下列界面元素中，不是容器的是（A）

5-3 下列关于实现图形用户界面的描述中，错误的是 （B,C）

A．放在容器中的组件首先要定义，接着要初始化

B．放在容器中的多个组件是要进行布局的，默认的布局策略是FlowLayout

C．容器中所有组件都是事件组件，都可以产生事件对象

D．事件处理是由监听者定义的方法来实现的

5-4 下列关于组件类的描述中，错误的是 （A）

A．组件类中包含了文本组件类（TextComponent）和菜单组件类（MenuComponent）

B．标签（Label）和按钮（Button）是组件类（Component）的子类

C．面板（Panel）和窗口（Window）是容器类（Container）的子类

D．文本框（TextField）和文本区（TextArea）是文本组件类（TextComponent）的子类

5-5 在对下列语句的解释中，错误的是 （D）

ionListener(this);

A．but是某种事件对象，如按钮事件对象

B．this表示当前容器

C．ActionListener是动作事件的监听者

D．该语句的功能是将but对象注册为this对象的监听者

5-6 所有事件类的父类是（B）

A．ActionEvent B．AwtEvent C．KeyEvent D．MouseEvent

5-7 所有GUI标准组件类的父类是 （C）

A．Buttom B．List C．Component D．Container

5-8 下列各种布局管理器中Window类、Dialog类和Frame类的默认布局是（C）

A．FlowLayout B．CardLayout C．BorderLayout D．GridLayout

5-9 在下列各种容器中，最简单的无边框的又不能移动和缩放的只能包含在另一种容器中的

容器是 （D）

A．Window B．Dialog C．Frame D．Panel

5-10 下列关于菜单和对话框的描述中，错误的是（C）

A．Frame容器是可以容纳菜单组件的容器

B．菜单条中可包含若干个菜单，菜单中又可包含若干菜单项，菜单项中还可包含菜单

子项

C．对话框与Frame一样都可作为程序的最外层容器

D．对话框内不含有菜单条，它由Frame弹出

判断题

5-1 AWT是抽象窗口工具包的英文缩写。（对）

5-2 容器中只能包含有组件，而不能再含有容器。（错）

5-3 容器分可以独立的窗口和不可以独立的窗口两种。（对）

5-4 单选按钮提供“多选一”的输入选择，下拉列表提供“多选多”的输入选择。（错）

5-5 所有容器的默认布局都是FlowLayout。（错）

5-6 所有的组件都是事件源。（错）

5-7 Java 2 的事件处理方法是采用委托事件处理模型。（对）

5-8 事件组件都应注册一个事件监听者。（对）

5-9 事件监听者除了得知事件的发生外，还应调用相应方法处理事件。（对）

5-10 所有事件的父类是EventObject类。（对）

5-11 图形用户界面是由用户自定义成分、控制组件和容器组成的。（对）

5-12 所有GUI标准组件类的父类是Component类。（对）

5-13 所有容器类的父类是Frame类。（错）

5-14 标准和按钮都是事件源。（对）

5-15 文本去和文本框都可以引发两种事件：文本改变事件和动作事件。（错）

5-16 每个复选框有两种状态：“打开”和“关闭”状态。（对）

5-17 复选框组（CheckboxGroup）是由若干个按钮组成的。在一组按钮中可选多个。（错）

5-18 列表（List）是由多个选项组成的，只可在列表框的若干个选项选取一个。（错）

5-19 下拉列表（Choice）是一种“多选多”的输入界面。（错）

5-20 滚动条有两类：水平滚动条和垂直滚动条。（对）

5-21 画布（Canvas）是一种可容纳多个组件的容器。（错）

5-22 所有容器都采用顺序布局（FlowLayout）作为默认布局管理器。（错）

5-23 边界布局（BorderLayout）将容器分为东、西、南、北共4个区域。（错）

5-24 卡片布局（CardLayout）可使容器容纳多个组件，在同一时刻只显示若干个组件中的一

个。（对）

5-25 容器可容纳组件和容器，同一个容器中的组件可被同时显示或者同时隐藏。（对）

5-26 所有容器都是有边框的。（错）

5-27 Panel容器是可以嵌套使用的。（对）

5-28 Applet实际是一种特殊的Panel容器。Java Applet程序只负责它拥有的Applet容器内的

无边框区域。（对）

5-29窗口（Window）容器是一种独立窗口，但它不能作为程序的最外层容器。（对）

5-30 Frame容器是有边框的容器，它也是一种独立窗口，只能作为最外层容器。（对）

5-31 Frame容器可以容纳菜单组件，它实现了MenuContainer接口。（对）

5-32 MenuComponent类是菜单组件的父类。（对）

5-33 菜单条（MunuBar）、菜单（Munu）、菜单项（MunuItem）是3中不同的菜单组件。（错）

5-34 对话框（Dialog）不是一种独立使用的容器。（错）

5-35 文件对话框（FileDialog）是对话框（Dialog）的子类，它是一种打开文件和保留文件的

对话框窗口。（对）

分析程序输出结果

5-1 Exer5_

import .*;

import .*;

public class Exer5_1 extends Applet

{

private Label lab1,lab2;

public void init()

{

lab1=new Label();

t("标签文本左对齐");

gnment();

lab2=new Label("标签文本右对齐",);

setLayout(new GridLayout(3,3));

add(lab1);add(lab2);

}

}

运行改程序后，输出结果如图5-5所示。

图5-5 分析题5-1输出结果

5-2 Exer5_

import .*;

import .*;

import .*;

public class Exer5_2 extends Applet implements ActionListener,ItemListener

{

List colList;

String colName[]={"黑色","蓝色","浅蓝色","绿色","红色","黄色"};

Color cols[]={,,,,,};

int t;

public void init()

{

colList=new List(4,false);

ionListener(this);

mListener(this);

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

(colName[i]);

add(colList);

}

public void actionPerformed(ActionEvent e)

{}

public void itemStateChanged(ItemEvent e)

{

showStatus(ectedItem()+";index"+ectedIndex());

t=ectedIndex();

repaint();

}

public void paint(Graphics g)

{

or(cols[t]);

ct(15,30,20,20);

}

}

运行改程序后，输出结果如图5-6所示。

5-3 Exer5_

import .*;

import .*;

public class Exer5_3 extends Frame implements ActionListener

{

Frame fr;

Panel deck;

CardLayout c1;

Button but[];

String name[]={"第一张","下一张","前一张","最末张"};

public Exer5_3()

{

fr=new Frame("卡片窗口");

deck=new Panel();

c1=new CardLayout();

out(c1);

Panel c1=new Panel();

Label lab1=new Label("卡片1");

(lab1);

(c1,t());

Panel c2=new Panel();

Label lab2=new Label("卡片2");

(lab2);

(c2,t());

Panel c3=new Panel();

Label lab3=new Label("卡片3");

(lab3);

(c3,t());

Panel c4=new Panel();

Label lab4=new Label("卡片4");

(lab4);

(c4,t());

Panel contr=new Panel();

out(new GridLayout(2,2));

but=new Button[];

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

{

but[i]=new Button(name[i]);

but[i].addActionListener(this);

(but[i]);

}

(contr,);

(deck,);

e(300,150);

();

}

public void actionPerformed(ActionEvent e)

{

if(rce()==but[0])

(deck);

if(rce()==but[1])

(deck);

if(rce()==but[2])

us(deck);

if(rce()==but[3])

(deck);

}

public static void main(String args[])

{

Exer5_3 m1=new Exer5_3();

}

}

运行该程序后，输出结果如图5-7所示。

5-4 Exer5_

import .*;

public class Exer5_4 extends Frame

{

TextField tf=new TextField("",30);

MenuBar mb1=new MenuBar();

Menu f=new Menu("文件");

Menu m=new Menu("照片");

Menu s=new Menu("储存");

String name[]={"第一张","下一张","前一张","最末张"};

CheckboxMenuItem[]save={new CheckboxMenuItem("保存"),new CheckboxMenuItem("另

存为")};

MenuItem[] file1={new MenuItem("打开"),new MenuItem("关闭")};

MenuBar mb2=new MenuBar();

Menu fo=new Menu("水果");

MenuItem[] fruit={new MenuItem("香蕉"),new MenuItem("苹果"),new MenuItem("李子

")};

Button but=new Button("Swap");

public Exer5_4()

{

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

{

(new MenuItem(name[i]));

if((i+1)%3==0)

arator();

}

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

(save[i]);

(s);

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

(file1[i]);

(f);

(m);

setMenuBar(mb1);

table(false);

add("Center",tf);

add("North",but);

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

(fruit[i]);

(fo);

}

public boolean handleEvent(Event e)

{

if(==_DESTROY)

(0);

else

return Event(e);

return true;

}

public boolean action(Event e,Object arg)

{

if((but))

{

MenuBar m=getMenuBar();

if(m==mb1)

setMenuBar(mb2);

else if(m==mb2)

setMenuBar(mb1);

}

else if( instanceof MenuItem)

{

if(("打开"))

{

String str=t();

Boolean ch=false;

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

if((name[i]))

ch=true;

if(!ch)

t("你按了打开菜单");

else

t("打开"+str);

}

else if((file1[1]))

(0);

else if((save[0]))

t("你按了保存菜单");

else if((save[1]))

t("你按了另存为菜单");

else

t(ng());

}

else

return (e,arg);

return true;

}

public static void main(String args[])

{

Exer5_4 ex=new Exer5_4();

e(new Dimension(200,200));

ible(true);

}

}运行该程序后，输出结果如图5-8所示。

2-7 Exer5_

import .*;

import .*;

class myDialogFrame extends Frame implements ActionListener

{

MenuItem aboutItem,exitItem;

aboutDialog myDialog;

public myDialogFrame()

{

setSize(300,200);

setTitle("我的联系窗口");

addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent

E){(0);}});

MenuBar mb=new MenuBar();

setMenuBar(mb);

Menu fm=new Menu("练习");

(fm);

aboutItem=new MenuItem("关于信息");

ionListener(this);

(aboutItem);

exitItem=new MenuItem("退出");

ionListener(this);

(exitItem);

}

public void actionPerformed(ActionEvent e)

{

Object sou=rce();

if(sou==aboutItem)

{

if(myDialog==null)

myDialog=new aboutDialog(this);

();

}

else if(sou==exitItem)

{(0);}

}

}

class aboutDialog extends Dialog

{

public aboutDialog(Frame parent)

{

super(parent,"信息框",true);

Panel p1=new Panel();

TextArea ta=new TextArea(10,30);

t("请写下你的信息");

(ta);

add("North",p1);

Panel p2=new Panel();

Button but=new Button("返回");

(but);

add("Center",p2);

ionListener(new ActionListener(){public

e){setVisible(false);}});

setSize(300,250);

}

void actionPerformed(ActionEvent

}

public class Exer5_5

{

public static void main(String args[])

{

Frame fr=new myDialogFrame();

();

}

}

运行该程序后，输出结果如图5-9所示。

编程题

2-18 使用Java Applet编写满足下列要求的程序：

（1）含有两个按钮和两个标签；

（2）含有文本框和文本区；

（3）含有一个按钮具有退出功能；

编写程序如下：

import .*;

import .*;

class pro5_1 extends WindowAdapter implication ActionListener

{

Frame f;

Label la1,la2;

Button b1,b2;

TextField tf;

int tag=0;

public static void main(String args[])

{

pro5_1 mywin=new pro5_1();

y();

}

public void display()

{

f=new Frame("我的现实窗口");

la1=new Label("标签1");

la2=new Label("标签2");

(la1,"North");

(la2,"West");

b1=new Button("现实字符串");

b2=new Button("退出");

ionListener(this);

(b1,"South");

ionListener(this);

(b2,"East");

tf=new TextField();

(tf,"Center");

dowListener(this);

e(400,200);

ible(true);

}

public void actionPerformed(ActionEvent e)

{

String s1="这是一个字符串";

String s2="这是另一个字符串";

if(ionCommand().equals("退出"))

(0);

if(tag==0)

{

t(s1);

tag=1;

}

else

{

t(s2);

tag=0;

}

}

public void windowClosing(WindowEvent e)

{

(0);

}

}

运行该程序后，输出结果如图5-10所示。

2-19 使用Java Application编写满足下列要求的程序。

3 使用GridLayout布局。

4 设计一个简单的计算器。包括数字按钮0~9，以及加、减、乘、除、清零、等于运算按

钮和一个现实计算结果的文本区。

请读者参照本书本章5.2程序距离中的例5.1的程序内容进行编写。

2-20 编写一个图形用户界面的Application程序。

6 有一个菜单条；

7 菜单条中有3个菜单；

8 每个菜单有2个菜单项，其中一个菜单项又具有2个菜单子项。

程序内容如下：

import .*;

import .*;

public class pro5_3 extends Frame implements ActionListener,ItemListener

{

TextField text;

public pro5_3()

{

super("一个联系菜单的窗口");

setSize(300,200);

}

public void init()

{

MenuBar myB=new MenuBar();

setMenuBar(myB);

Menu m1=new Menu("文件");

(new MenuItem("保存"));

arator();

("退出");

ionListener(this);

(m1);

Menu m2=new Menu("编辑");

("复制");

arator();

("全选");

ionListener(this);

(m2);

Menu m3=new Menu("插入");

("页码");

arator();

Menu m31=new Menu("图片");

("来自剪贴画");

("来自图形文件");

(m31);

ionListener(this);

(m3);

text=new TextField();

add("South",text);

}

public static void main(String args[])

{

pro5_3 myMenu=new pro5_3();

();

ible(true);

}

public void itemStateCharged(ItemEvent e)

{

t("状态改变");

}

public void actionPerformed(ActionEvent e)

{

t(ionCommand());

if(ionCommand()=="退出")

(0);

}

}

运行该程序后，输出结果如图5-11所示。

5-4 编写一个可以弹出对话框的程序。

请读者参考本书本章5.2程序举例中的例5.4的程序内容进行编程。

第6章 异常和异常处理

选择题

6-1.下列关于异常的描述中，错误的是（B）

A．异常是一种经过修正后程序仍可执行的错误

B．异常是一种程序在运行中出现的不可恢复执行的错误

C．不仅Java语言有异常处理，C++语言也有异常处理

D．出现异常不是简单结束程序，而是执行某种处理异常的代码，设法恢复程序的执行

6-2.下列关于异常处理的描述中，错误的是（D）

A．程序运行时异常由Java虚拟机自动进行处理

B．使用try-catch-finally语句捕获异常

C．使用throw语句抛出异常

D．捕获到的异常只能用当前方法中处理，不能用其他方法中处理

6-3.下列关于try-catch-finally语句的描述中，错误的是（A）

A．try语句后面的程序段将给出处理异常的语句

B．catch（）方法跟在try语句后面，它可以是一个或多个

C．catch（）方法有一个参数，该参数是某种异常类的对象

D．finally语句后面的程序段总是被执行的，该语句起到提供统一接口的作用

6-4.下列关于抛出异常的描述中，错误的是（D）

A．捕捉到发生的异常可在当前方法中处理，也可以抛到调用该方法的方法中处理

B．在说明要抛出异常的方法时应加关键字throw<异常列表>

C．<异常列表>中可以有多个用逗号分隔的异常

D．抛出异常的方法中要使用下述抛出异常语句：throw<异常名>；其中，<异常名>是异

常类的类名

6-5.下列关于用户创建自己的异常描述中，错误的是（D）

A．创建自己的异常应先创建一个异常类

B．为实现抛出异常，须在可能抛出异常的方法中书写throw语句

C．捕捉异常的方法是使用try-catch-finally语句格式

D．使用异常处理不会使整个系统更加安全和稳定

判断题

6-1.异常是一种特殊的运行错误的对象。（对）

6-2.异常处理可以使整个系统更加安全和稳定。（对）

6-3.异常处理是在编译时进行的。（错）

语言中异常类都是ble的子类。（对）

ble类有两个子类：Error类和Exception类。前者由系统保留，后者供应用程序

使用。(对)

6-6.异常通常是指Error类和Exception类。（错）

ion类只有一个子类为RuntimeException。（错）

6-8.在异常处理中，出现异常和抛出异常是一回事。（错）

6-9.运行时异常是在运行时系统检测并处理的。（错）

6-10．使用try-catch-finally语句只能捕获一个异常。（错）

6-11.捕获异常时try语句后面通常跟有一个或多个catch（）方法用来处理try块内生成的异

常事件。（对）

6-12．使用finally语句的程序代码为该程序提供一个统一的的出口。（对）

6-13.抛出异常的方法说明中要加关键字throws，并在该方法中还应添加throw语句。（对）

6-14.创建异常类时要给出该异常类的父类。（对）

6-15.如果异常类没有被捕获将会产生不正常的终止。（对）

分析程序的输出结果题

6_

public class Exer6_1

{

public static void main(String args[] )

{

int x=10,y=0;

int z=x/y;

n(“z=“+z);

}

}

该程序运行后，输出结果如图所示：

D:JAVAXT>java Exer6_1

Exception in thread”main”eticException:/by zero

At Exer6_

6_

public class Exer6_2

{

public static void main(String args[])

{

int array1[]={6,0,8};

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

{

try

{

int d=100/array[i];

n(“t 正常:d=“+d);

}

catch(ArithmeticException e)

{

n("t算术异常")；

}

catch(ArrayIndexOutOfBoundsException e)

{

n("t下标越界异常");

}

finally

{

n("t异常处理结束！n")；

}

}

}

｝

运行该程序后，输出如图所示

D:JAVAXT>java Exer6_2

正常：d=16

异常处理结束！

算术异常！

异常处理结束！

正常：d=12

异常处理结束！

下标越界异常！

异常处理结束！

6-3 Exer6_

public class Exer6_3

{

public static void main(String args[])

{

int array1[]={6,0,8};

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

{

try

{

int d=100/array1[i];

n("t正常：d="+d);

}

catch(RuntimeException e)

{

n("t异常:"+ng());

}

finally

{

n("t异常处理结束！n");

}

}

}

}

运行该程序后，输出结果如图所示：

D:JAVAXT>java Exer6_3

正常：d=16

异常处理结束！

异常：eticException:/by zero

异常处理结束！

正常：d=12

异常处理结束！

异常：ndexOutOfBoundsExcepiton:3

异常处理结束！

6-4 Exer6_

public class Exer6_4

{

public static void Test()

{

int a[]=new int[3];

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

{

try

{

a[i]=i+5;

n("t正常：a["+i+"]="+a[i]);

}

catch(ArrayIndexOutOfBoundsException e)

{

n("t异常：+ng()");

throw e;

}

}

}

public static void main(String args[])

{

try

{

Test();

}

finally

{

n("t异常处理结束！n")

}

}

}

运行该程序后，输出结果如图：

D:JAVAXT>java Exer6_4

正常：a[0]=5

正常：a[1]=6

正常：a[2]=7

异常：ndexOutOfBoudsException: 3

异常处理结束！

Exception in thread “main” ndexOutOfBoundsExcepiton:3

at Exer6_

at Exer6_

6-5 Exer6_

class myException extends Exception

{

static int a=0

myException(String s)

{

super(s);

a++;

}

String show()

{

return"自定义异常出现的次数："+a;

}

}

Public class Exer6_5

{

static void Test() throws myException

{

myException e;

e=new myException("自定义异常n");

throw e;

}

Public static void main(String args[])

{

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

{

try

{

Test();

}

catch(myException e)

{

n(());

n(ng);

}

}

}

}

运行该程序后，输出结果如图所示：

D:JAVAXT>java Exer6_5

自定义异常出现的次数：1

myException:自定义异常

自定义异常出现的次数：2

myException:自定义异常

自定义异常出现的次数：3

myException:自定义异常

5.简单回答题

5 检测异常事件必须使用什么语句？

答：try语句

6 catch()方法的作用是什么？该方法用户能否调用？

答： 用来处理try块中检测出的异常事件。

7 catch()方法中异常类型应与什么相符？

答：与生成的异常事件类型相符。

8 异常示被捕获到将会出现什么现象？

答：try语句后边的惯常处理代码将不被执行，通常使用finally语句提供一个统一出口。

9 在一个try语句的程序代码块中可以捕获多个异常吗？

答：可以

10 使用throw语句抛出的是类型还是对象？

答：抛出的是对象。

11 捕获到的异常还可以再抛出吗？

答：可以。

12 Finally语句块中的代码何时被执行？

答：在异常事件处理的方法catch()执行后执行。

13 语句throw的作用是什么？

答：抛出所检测到的异常。

14 异常类Exception的父类是什么？

答：是Throwable类。

编程题

2. 编程实现下述异常，并输出显示适当的错误信息。

2-1 数组下标越界异常ArrayIndexOutOfBoundsException类型。例如，

char ch[]=new char[5];

ch[5]='m';//产生该类型异常

（2） 对象转换异常ClassCastException类型。

例如，将对象a1转换为对象a2时，如果a1和a2不是同类，并且a1也不是a2

的子类对象时，则产生该类型异常。

1-1 引用空对象的变量和方法时产生NullPointerException异常类型。例如，

int ar[]=null;

n（）；//产生该类异常

（1） 关于数组下标越界异常ArrayIndexOutOfBoundsException请参照本书本章例6.1

的程序，请读者自行编写。

（2） 下面关于对象转换的例子。程序内容如下：

public class pro6_1

{

public static void main(String args[])

{

try{

M();

}

catch(ClassCastException e)

{

n("对象转换异常");

}

}

static void M()throws ClassCastException

{

Object obj=new Object();

int arr[]=(int[])(obj);

}

}

（3） 编写处理异常程序如下：

public class pro6_2

{

public static void main(String args[])

{

try{

int ar[]=null;

n();

}

catch(NullPointerException e)

{

n("Exception:"+e);

}

}

}

运行该程序后，输出显示结果如下：

Exception：. NullPointerException.

6-2 定义一个circle类，其中有求面积的方法，当圆的半径小于0时，抛出一个自定义的异

常。编程实现之：

程序内容如下；

class Circle extends Exception

{

double r;

Circle()

{ }

Circle(double i)

{r=i;}

public double getr()

{return r;}

public double Area()

{

return 3.1415*r*r;

}

}

public class pro6_3

{

public static void main(String args[])

{

Circle c=new Circle(-3.0);

try

{

if(()<0)

{

Circle ee=new Circle();

throw ee;

}

n(());

}

catch(Circle e)

{

n("自定义异常："+e);

}

}

}

运行该程序后，输出显示如下结果：

自定义异常：Circle

如果将语句

Circle c=new Circle(-3.0);

必为

Circle c=new Circle(3.0);

输出结果如何？请读者上机试试。