习 题 一
1． 简述面向对象软件开发方法的重要意义。
【答】：
面向对象的软件开发方法按问题论域来设计模块，以对象代表问题解的中心环节，力求
符合人们日常的思维习惯，采用“对象+消息”的程序设计模式，降低或分解问题的难度
和复杂性，从而以较小的代价和较高的收益获得较满意的效果，满足软件工程发展需要。
2．解释下面几个概念：
1）对象 2）实例 3）类 4）消息 5）封装 6）继承 7）多态
【答】：
1） 对象：就是现实世界中某个具体的物理实体在计算机中的映射和体现,是由属性和
操作所构成的一个封闭整体。
2） 实例：是对象在计算机内存中的映像。
3） 类：是描述对象的“基本原型”，是描述性的类别或模板，即对一组对象的抽象。
它定义一组对象所能拥有的共同特征，用以说明该组对象的能力与性质。
4） 消息：消息是对象之间进行通信的一种数据结构。
5） 封装：封装性是保证软件部件具有优良的模块性的基础。面向对象的类是封装良好
的模块，类定义将其说明（用户可见的外部接口）与实现（用户不可见的内部实现）
显式地分开，其内部实现按其具体定义的作用域提供保护。
6） 继承：继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。
7） 多态：多态性是指一个名字具有多种语义，即指同一消息为不同对象所接受时，可
以导致不同的操作。
3． 对象“汽车”与对象“小汽车”是什么关系，对象“汽车”与“轮胎”又是什么关系？
【答】：
对象“汽车”与对象“小汽车”具有继承关系，即对象“小汽车”继承了对象“汽车”。
“轮胎”是对象“汽车”的一个属性，所以对象“汽车”包含“轮胎”，二者是包含关
系。
4． 简述Java语言的主要特点。
【答】：
Java语言的主要特点：（1）简单性 （2）面向对象 （3）分布式 （4）健壮性 （5）
结构中立 （6）安全性 （7）可移植 （8）解释的（9）高性能 （10）多线程 （11）
动态性
5．简述Java语言与C/C++语言的主要差异。
【答】：
Java基于C++，与之有许多相似之处，但其设计更易于使用，它们之间主要差异有：
（1）Java中无C／C++中最复杂并有潜在危险的指针
（2）Java无C/C++中的#include 、#define和头文件。
（3）Java无C/C++中的structure,union及typedef。
（4）Java无C/C++中的函数、指针和多重继承。
（5）Java无C/C++中的goto指令。
（6）Java无C/C++中的操作符重载(Operatior Overloading)、自动类型的转换
。
（7）Java系统要求对对象进行相容性检查，以防止不安全的类型转换。
（8） Java语言最强大的特性之一是它的平台独立性，Java可以处理好平台之间的
移植问题。
（9）Java语言中没有全局变量的定义，只能通过公用的静态的变量实现，从而减少了
引起错误的地方。
6．什么叫Java虚拟机？什么叫Java的字节码？
【答】：
Java虚拟机是一个软件系统，它可以翻译并运行Java字节码。它是Java的核心，保
证了在任何异构的环境下都可运行Java程序，解决了Java的跨平台的问题。
Java的字节码（byte‐code）是与平台无关的是虚拟机的机器指令
7．简述Java程序的运行过程。
【答】：
首先编写Java源代码程序，通过Java虚拟机编译成.class的字节码程序。然后通过然
后再执行翻译所生成的字节代码，属于先解释后执行方式。在运行时，字节码载入器
用于调入包含、继承所用到的所有类，确定内存分配，变成真正可执行的机器码。由，
再通过字节码校验器就是用于检验字节码是否正确，如果通过校验，再由系统执行平
台解释执行。
8．Java程序分哪两类？各有什么特点？
【答】：
Java程序根据程序结构的组成和运行环境的不同可以分为两类：Java Application（Java
独立应用程序）和Java Applet（Java小应用程序）。Java独立应用程序是一个完整的程
序，需要独立的Java解释器来解释执行；而Java小应用程序则是嵌在Web页面中的非
独立应用程序，由Web浏览器内部所包含的Java解释器来解释执行，为Web页面增加
交互性和动态性。
习 题 二
1． Java语言对标识符命名有何规定，下面这些标识符哪些是合法的，哪些是不合法的。
1）Myname 2) JavaLanguage 3) 2Person 4) _is_Has 5) $12345。
【答】：
合法的标识符有：Myname、JavaLanguage、_is_Has
非法的标识符有：2Person、$12345
2．Java有哪些基本数据类型，与C/C++相比有何特点？复合数据类型是哪几种？
【答】：
基本数据类型有：整型数据类型（字节整型、短整型、整型、长整型），实数数据类型
（单精度实数、双精度实数），字符数据类型和布尔数据类型。
与C/C++相比，Java的数据类型与C++相似，但有两点不同：①在Java语言中所有的数
据类型是确定的，与平台无关，所以在Java中无sizeof操作符；②Java中每种数据类型都对
应一个默认值。这两点体现了Java语言的跨平台性和完全稳定性。
Java的复合类型是由用户根据需要自己定义并实现其运算的数据类型，主要有类类型、
接口和数组等。
3． Java的字符类型采用何种编码方案？有何
特点？
【答】：
Java的字符类型采用16位Unicode（全球文字共享编码）方式，用16位来表示东西方
字符。由于采用Unicode编码方案，使得Java在处理多语种的能力方面得到大大提高，从
而为Java程序在基于不同语种之间实现平滑移植铺平了道路。
4． Java有哪些运算符和表达式？请写出下面这些表达式的运算结果（设a =2,b = – 3,
f = true）。
1）– –a%b++ 2) (a>=1)&&a<=12?a:b) 3) f^(a>b) 4) (– –a)<
【答】：
Java的运算符主要由算术运算符、关系运算符、条件运算符、位运算符、逻辑运算符
以及赋值运算符。表达式由运算符、操作数和方法调用，按照语言的语法规则构造
而成的符号序列。
表达式的结构是：
1）– –a%b++的结果是：1
2）(a>=1)&&a<=12?a:b)的结果是：1
3）f^(a>b)的结果是：false
4）(– –a)<
5．Java中标准输入输出使用哪种系统类、使用哪个对象和方法？
【答】：
通过系统类https://www.doczj.com/doc/0510298717.html,ng.System达到访问标准输入输出的功能。System类管理标准输入输
出流和错误流，有以下三个对象：
1）System.out：把输出送到默认的显示（通常是显示器）。常使用输出的方法有print()、
println()等。
2）System.in：从标准输入获取输入（通常是键盘）。常实现输入处理的方法有read()、
skip()等；
3）System.err：把错误信息送到默认的显示。常见方法有print()、println()、write()等。
6．阅读下列程序，写出运行结果。
(1)．
public class Example0401{
public static void main(String[] args){
for(int x=0;x<10;x++){
int y=x*x+x+41';
System.out.println("\t"+x+"\t"+y);
}
}
}
(2)．菲波拉契数列：
public class Example02{
public static void main(String[] args){
System.out.print(0)
int fib0=0;
int fib1=1;
int fib2=fib0+fib1
while(fib2<100){
fib0=fib1;
fib1=fib2;
fib2=fib1+fib0;
System.out.print(","+fib1);
}
}
}
（3）．产生0~20的随机整型，然后计算并打印它的结果：
import java.util.Random;
public class Example03{
public static void main(String[] args){
Random random=new Random();
float x=random.nextFloat();
int n=Math.round(21*x);
long f=1;
int k=1;
do
f*=k++;
while(k<=n);
System.out.println(n+"!="+f);
}
}
（4）．三重循环：
public class Example05{
public static void main(String[] args){
for(int i=0;i<3;i++){
resume:
for(int j=0;j<3;j++){
for(int k=0;k<3;k++){
System.out.println("\n"+i+" "+j+' "+k);
if (i==1&& k==0) break resume;
}
System.out.println("\tEnd of k loop;j="+j);
}
System.out.println("\tEnd of j loop;i="+i);
}
System.o
ut.println("\tEnd of i loop.")
}
}
【答】：
（1）的运行结果如下：
0 41
1 43
2 47
3 53
4 61
5 71
6 83
7 97
8 113
9 131
（2）的运行结果如下：
0,1,2,3,5,8,13,21,34,55,89
（3）的运行结果如下：
运行结果取决于随机数。求随机数的阶乘，其中的一个运行结果如下：
3!=6
（4）的运行结果如下：
0 0 0
0 0 1
0 0 2
End of k loop;j=0
0 1 0
0 1 1
0 1 2
End of k loop;j=1
0 2 0
0 2 1
0 2 2
End of k loop;j=2
End of j loop;i=0
1 0 0
End of j loop;i=1
2 0 0
2 0 1
2 0 2
End of k loop;j=0
2 1 0
2 1 1
2 1 2
End of k loop;j=1
2 2 0
2 2 1
2 2 2
End of k loop;j=2
End of j loop;i=2
End of i loop.
7．分析下面两个三重循环程序之间的差别，写出结果，然后上机进行检验。
（1）．三重循环1：
public class Example01{
public static void main(String[] args){
int count=0;
for(int i=0;i<3;i++)
resume:
for(int j=0;j<4;j++)
for(int k=0;k<5;k++){
++count;
if (i==1&&j==2&& k==3) break resume;
}
System.out.println("\tcount="+count);
}
}
（2）．三重循环2：
public class Example02{
public static void main(String[] args){
int count=0;
for(int i=0;i<3;i++){
resume:
for(int j=0;j<4;j++)
for(int k=0;k<5;k++){
++count;
if (i==1&&j==2&& k==3) break resume;
}
System.out.println("\tcount="+count);
}
}
}。
【答】：
在三重循环1中，System.out.println()语句是在三重循环之外的，输出的是count的最后
的值，而三重循环2中，System.out.println()语句在循环体内，输出的是每次循环后count发
生变化的值。
三重循环1的运行结果是： count=54
三重循环2的运行结果是：
count=20
count=34
count=54
习 题 三
1．Java程序中字符串常量使用什么类表示？字符串变量又使用什么类来表示？它们的
主要区别在哪里？
【答】：
字符串常量常用https://www.doczj.com/doc/0510298717.html,ng.String类表示，字符串变量常用https://www.doczj.com/doc/0510298717.html,ng.StringBuffer类来表
示。它们的主要区别在于：String对象一旦创建不会发生变化，具有只读性质；而StringBuffer
对象创建后可扩充和修改字符串对象的内容。
2．请说明程序“String s1="I like ";s1+="Java!"；”和程序“StringBuffer s1=new
StringBuffer("I like ");s1.append("Java!")；”的区别。根据你得出的结论，如果程序需要处理
大量的字符串连接操作，应该尽量使用String类还是StringBuffer类？
【答】：
程序“String s1="I like ";s1+="Java!"；”中，s1表示字符串变量
，在执行第一次运算时，
s1赋值一个字符串对象“I like ”，而第二次运算，s1被赋值另一个字符串对象“I like Java”，
二次运算中赋值的对象完全不同。而对于程序“StringBuffer s1=new StringBuffer("I like
");s1.append("Java!")；”，变量s1在两次运算中始终表示一个字符串对象，只是这个字符串对
象的内容发生了变化。
程序在处理大量的字符串连接操作，尽量使用StringBuffer类的对象来处理。这是因为
StringBuffer对象可以扩充和修改字符串对象，有利于减少系统资源的消耗。
3．编写一个Applet，使之能将定长字符串转化成可变长字符串，并能实现字符串中指
定字符的替换。
【答】：
Applet的程序如下：
package javabook.answer.ch03;
import javax.swing.JApplet;
import java.awt.*;
public class Demo3 extends JApplet {
/**
* 字符串替换操作
*
*/
public void init() {
try {
str = this.getParameter("str");
strR = new StringBuffer(str);
pch = this.getParameter("ch1").charAt(0);
tch = this.getParameter("ch2").charAt(0);
} catch (Exception e) {
System.out.println("初始化数据出现错误！");
}
for (int i = 0; i < strR.length(); i++) {
if (strR.charAt(i) == pch) {// 替换
strR.setCharAt(i, tch);
}
}
}
public void paint(Graphics g) {
g.drawString("原来的字符串：" + str, 20, 20);
g.drawString("替换后的字符串：" + strR, 120, 120);
}
private String str;
private StringBuffer strR;
private char pch;
private char tch;
}
对应的HTML的文件如下：
ln(s1.toUpperCase()+"\n");
System.out.println("s4的长度="+s4.length());
System.out.println(s4.append(s5));
System.out.println(s4.insert(2,365.25f));
System.out.println(s4.insert(0,"INSERTED"));
char c2[]=new char[s4.length()];
s4.getChars(0, s4.length(), c2, 0);
for(int i=0;i
System.out.println(c2[i]+" ");
System.out.println(s4.toString().toUpperCase());
}
}
【答】：
上列程序StringTest的运行结果如下：
s1和s2相同吗？不同
s2和s3相同吗？相同
s1连接s2后的字符串为：I love Java.I like Java.
true
true
I
l
o
v
e
J
a
v
a
.
I LOVE JAVA.
s4的长度=12
I love Java.Append
I 365.25love Java.Append
INSERTEDI 365.25love Java.Append
I
N
S
E
R
T
E
D
I
3
6
5
.
2
5
l
o
v
e
J
a
v
a
.
A
p
p
e
n
d
INSERTEDI 365.25LOVE JAVA.APPEND
s1的长度=12
习 题 四
1． 写出类的格式声明中允许使用的关键字。它们代表的含义是什么？
【答】：
类的格式声明允许使用的关键字有：abstract、static、final、public、class、
implements以及extends等。abstract表示定义一个抽象类，static用于定义静态嵌套类、
final定义一个最终类，public定义一个公共类、class表示定义一个类、implements表示
定义的类实现的接口以及用extends表示该类继承某类。
2．类的成员数据的修饰符是否和类的成员方法部分相同，部分不同。请写出与成员方
法不同的修饰符是哪些？它们的含义是什么？
【答】：
类的成员数据修饰符有部分和成员方法相同，如访问控制符、static、final等。有部分
的修饰符存在不同。对于成员变量与成员方法不同的修饰符有：transient（说明变量不能被
序列化）、volatile（表示变量能从主存读取，进行异步修改）；对于成员方法与成员变量不同
的修饰符有：native（定义本地方法）、abstract（定义抽象方法）、synchronized（定义同步方
法）。
3．写出构造方法的定义和用途？
【答】：
构造方法是一种特殊的方法，它与类名同名，但不具有返回值。构造方法由用户自定
义，如果没有定义系统会自动创建一个默认的无参构造方法。构造方法用于对象的创建和初
始化。
4．关键字static在修饰类、类的成员数据和类的成员方法中的作用各是什么？
【答】：
static在修饰类时，往往修饰类中定义的嵌套类，也称为静态嵌套类，提高了类的封装
性。static在修饰类的成员数据和成员方法时，表示定义一个静态成员，该成员为类成员，
为该类的所
有对象共享。
5．定义一个点类“Point”。Point类的属性有x轴和y轴坐标，可以通过方法setX（）
设置x轴坐标，方法setY（）设置y轴坐标，方法getY（）获得x轴坐标，方法getY（）
获得y轴坐标。编写一个测试类PointTest来创建Point类的对象，测试该类。
【答】：
package javabook.answer.ch04;
import java.util.*;
class Point {
private double x;
private double y;
public Point() {
x = 0;
y = 0;
}
public Point(double x, double y) {
setX(x);
setY(y);
}
public double getX() {
return x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return y;
}
public void setY(double y) {
this.y = y;
}
}
public class EX5 {
public static void main(String args[]) {
Scanner in = new Scanner(System.in);
double x, y;
System.out.println("输入X坐标:");
x = in.nextDouble();
System.out.println("输入Y坐标:");
y = in.nextDouble();
Point p = new Point(x, y);
System.out.println("点的坐标:x=" + p.getX() + ",y=" + p.getY());
System.exit(0);
}
}
6．this关键字的含义是什么？它的主要用途有哪些？
【答】：
this关键字表示当前对象。它可以实现对对象成员的访问，可以实现在构造方法内调用
其他的构造方法来创建和初始化对象。
7．写出嵌套类的分类，并加以区分。
【答】：
嵌套类是在一个类内定义另外一个类。根据static的存在性分成两大类：静态嵌套类和
内部类。有static关键字为静态嵌套类，外部类的所有成员可以共享该静态嵌套类。无static
修饰的嵌套类为内部类。内部类必须与外部类的实例相关联，通过外部类的对象创建内部类
的对象实例。
8．编程定义一个队列类，它封装了队列数组，判断队列空方法、队列满方法、进队列
方法和出队列方法。
【答】：
队列类Queue的定义如下：
package javabook.answer.ch04;
public class EX8 {
private int length;// 队列长度;
private int[] s;// 队列数组;
private int top;// 队头;
private int rear;// 队尾;
public EX8(int length) {
this.length = length;
if (length > 0)
s = new int[length];// 初始化队列
top = rear = 0;// 队列空;
}
public int getTop() {// 获取队头元素;
if (!isEmpty()) {
return s[top];
}
return 0;
}
public int getRear() {// 获取队尾元素;
if (!isEmpty()) {
return s[rear];
}
return 0;
}
public void enQueue(int content) {// 进队列;
if (!isFull()) {
s[rear] = content;
rear = (rear + 1) % length;
}
}
public
void delQueue() {// 出队列
if (!isEmpty()) {
top = (top + 1) % length;
}
}
public boolean isFull() {// 判断队列满
if ((rear + 1) % length == top)
return true;
return false;
}
public boolean isEmpty() {// 判断队列空
if (rear == top)
return true;
return false;
}
}
9．编程定义一个栈类，它封装了栈数组，判断栈空方法、栈满方法以及进栈和出栈方
法。
【答】：
栈类Stack的定义如下列代码所示：
package javabook.answer.ch04;
public class EX9 {
private int length;
private int top;
private int[] s;
public EX9(int len) {// 初始化空栈
this.length = len;// 设置栈的空间大小
if (len > 0)
s = new int[len];
top = 0;// 设置为空栈
}
public int getTop() {// 获得栈顶元素
return s[top];
}
public boolean isFull() {// 判断栈满
if (top + 1 > length) {
return true;
}
return false;
}
public boolean isEmpty() {// 判断栈空
if (top < 1)
return true;
return false;
}
public void push(int content) {// 进栈
if (!isFull())
s[++top] = content;
}
public void pop() {// 出栈
if (!isEmpty()) {
--top;
}
}
}
10．编写一个类实现复数的运算。
【答】：
定义复数的类Complex，代码如下：
package javabook.answer.ch04;
public class EX10 {
private double real;
private double image;
public EX10(double real, double image) {
super();
this.real = real;
this.image = image;
}
public double getImage() {
return image;
}
public void setImage(double image) {
this.image = image;
}
public double getReal() {
return real;
}
public void setReal(double real) {
this.real = real;
}
public EX10 add(EX10 b) {// 复数相加
return new EX10(this.getReal() + b.getReal(), this.getImage()
+ b.getImage());
}
public EX10 sub(EX10 b) {// 复数相减
return new EX10(this.getReal() - b.getReal(), this.getImage()
- b.getImage());
}
public EX10 multiple(EX10 b) {// 复数相乘
double real, image;
real = this.getReal() * b.getReal() - this.getImage() * b.getImage();
image = this.getReal() * b.getImage() + this.getImage() * b.getReal();
return new EX10(real, image);
}
public EX10 div(EX10 b) {// 复数相除
double real, image, temp;
temp = Math.pow(b.getReal(), 2) + Math.pow(b.getImage(), 2);
real = (this.getReal() * b.getReal() + this.getImage() * b.getImage())
/ temp;
image = (this.getImage() * b.getReal() - this.getReal() * b.getImage())
/ temp;
return new EX10(real, image);
}
public static voi
d main(String args[]) {
EX10 a = new EX10(3, 4);
EX10 b = new EX10(3, -3);
EX10 result;
System.out.println("复数相加:");
result = a.add(b);
System.out.println("" + result.getReal() + "+i" + result.getImage());
System.out.println("复数相乘:");
result = a.multiple(b);
System.out.println("" + result.getReal() + "+i" + result.getImage());
System.exit(0);
}
}
习 题 五
1．子类将继承父类所有的属性和方法吗？为什么？在什么情况下会出现子类对父类变
量的隐藏？什么情况下出现子类对父类方法的覆盖？试举一例。
【答】：
子类继承父类的共有和保护类型的方法和属性，但是对于父类的私有方法和属性无法继
承。如果子类覆盖了父类的静态方法，父类的方法被隐藏。而覆盖是子类具有重新定义父类
成员方法的能力，例如：智能手机是手机的子类，手机可以打电话，而智能手机可以具有打
电话并增加传递视频信号的功能，重新定义手机打电话的功能。
2．方法的覆盖和方法的重载有什么不同？
【答】：
方法的覆盖是子类重新定义父类的成员方法，这意味着子类定义的方法具有和父类的方
法具有同方法名、同参数类型、同参数类型以及同返回值。而方法的重载是在同一个类中定
义同名方法的情况，这些同名方法除了方法名相同，但方法签名必须不同。
3．接口是什么？它将起何种作用？如何定义接口？如何使用接口？假设复数类实现了
一个四则运算的接口，试编程建立并使用这个接口？
【答】：
接口是为外界提供运算，并不提供运算的结构或具体的实现内容。接口是通过
interface来实现的，形如“interface 接口名”。实现复数四则运算的接口代码如下：
package javabook.answer.ch05;
interface ComplexCounter {
public abstract EX3 add(EX3 b);
public abstract EX3 sub(EX3 b);
public abstract EX3 div(EX3 b);
public abstract EX3 mul(EX3 b);
}
public class EX3 implements ComplexCounter {
private double real;
private double image;
public EX3(double real, double image) {
super();
this.real = real;
this.image = image;
}
public double getImage() {
return image;
}
public void setImage(double image) {
this.image = image;
}
public double getReal() {
return real;
}
public void setReal(double real) {
this.real = real;
}
public EX3 add(EX3 b) {// 复数相加
return new EX3(this.getReal() + b.getReal(), this.getImage()
+ b.getImage());
}
public EX3 sub(EX3 b) {// 复数相减
return new EX3(this.getReal() - b.getReal(), this.getImage()
- b.getImage());
}
public EX3 mul(EX3 b) {// 复数相乘
double real, image;
real = this.getReal() * b.getReal() - this.getImage() * b.getImage();
image = this.getReal() * b.getImage() + this.getImage() * b.getReal();
return new EX3(real, image);
}
public EX3 div(EX3 b) {// 复数相除
double real, image, temp;
temp = Math.pow(b.getReal(), 2) + Math.pow(b.getImage(), 2);
real = (this.getReal() * b.getReal() + this.getImage() * b.getImage())
/ temp;
image = (this.getImage() * b.getReal() - this.getReal() * b.getImage())
/ temp;
return new EX3(real, image);
}
}
4．计算
式1：y=x+x/2+x/3+……+x/n；
式2：y=x+x/2!+x/3!+……+x/n!；
要求：○1x为实数，n为正整数。 ○2任意输入n，当n为奇数时，按照式1计算，当n为偶
数时，按照式2计算。○3利用继承机制编程。
【答】：
MathCounter程序，实现式1运算如下：
package javabook.answer.ch05;
interface Counter {
public abstract double sum();
public abstract double div(double x, int n);
}
public class EX4a implements Counter {
private int n;
private double x;
public EX4a(double x, int n) {
this.n = n;
this.x = x;
}
public double sum() {
double result = 0;
if (n > 0)
for (int i = 1; i <= n; i++) {
result += div(x, i);
}
return result;
}
public double div(double x, int n) {
if (n != 0)
return x / n;
return 0;
}
}
FacMathCounter程序，实现式2的运算以及运算测试如下：
package javabook.answer.ch05;
import java.util.*;
public class EX4b extends EX4a {
private double x;
private int n;
public EX4b(double x, int n) {
super(x, n);
this.x = x;
this.n = n;
}
public double div(double x, int n) {
return x / fac(n);
}
public double fac(int n) {
int result = 1;
for (int i = 1; i <= n; i++)
result *= i;
return result;
}
public static void main(String args[]) {
Scanner in = new Scanner(System.in);
EX4a s;
System.out.println("输入实数：");
double xx = in.nextDouble();
System.out.println("输入整数：");
int nn = in.nextInt();
if (nn % 2 == 0)
s = new EX4b(xx, nn);
else
s = new EX4a(xx, nn);
System.out.println("运算结果是：" + s.sum());
System.exit(0);
}
}
5．编程通过继承线性表实现栈数据结构以及操作。
【答】：
线性表LineList类的定义如下：
package javabook.answer.ch05;
public class EX5LineList {
char[] list;
int cur;// 当前元素
public EX5LineList(char[] list) {
this.list = list;
cur = 0;
}
public void destroyList() {// 销毁线性表
this.list = null;
cur = -1;
}
public int getLength() {// 获取线性表的长度
return this.list.length;
}
public char getElement(int index) {// 获取指定位置的元素
if (index < getLength() && index >= 0)
return list[index];
return 0;
}
public int getLocation(char c) {// 获取指定元素的位置
for (int i = 0; i < list.length; i++)
if (c == list[i])
return i;
return -1;
}
public char getPriorContent() {// 获取前驱
if (cur > 0 && cur < list.length)
return list[cur - 1];
return 0;
}
public char getNextContent() {// 获取后继
if (cur >= 0 && cur < list.length - 1)
return list[cur + 1];
return 0;
}
public boolean insert(char c) {// 插入元素
if (++cur < list.length) {
list[cur] = c;
return true;
}
return false;
}
public boolean delete(int index) {// 删除第index元素
if (index <= cur && index >= 0) {
for (int i = index; i <= cur; i++)
list[i] = list[i + 1];
return true;
}
return false;
}
}
继承线性表LineList的栈Stack类的定义如下：
package javabook.answer.ch05;
public class EX5Stack extends EX5LineList {
char[] list;
int top;
public EX5Stack(char[] list) {
super(list);
this.list = list;
top = 0;
}
public void push(char c) {
if (insert(c))
top++;
}
public void pop() {
if (delete(top))
top--;
}
public char getTop() {
return getElement(top);
}
}
6．利用接口编写三角形、梯形面积及周长的程序。
【答】：
package javabook.answer.ch05;
import java.util.*;
interface TriInf {
public abstract double area();
public abstract double perimeter();
}
public class EX6 implements TriInf {
double a = 0, b = 0, c = 0;// 定义三边长;
public EX6(double a, double b, double c) {
this.a = a;
this.b = b;
this.c = c;
}
public double area() {
double d = (a + b + c) / 2;
return Math.sqrt(d * (d - a) * (d - b) * (d - c));
}
public double perimeter() {
return a + b + c;
}
public static void main(String args[]) {
Scanner in = new Scanner(System.in);
double aa, bb, cc;
System.out.println("输入三角形三边:");
aa = in.nextDouble();
bb = in.nextDouble();
cc = in.nextDouble();
EX6 t = new EX6(aa, bb, cc);
System.out.println("三角形的面积=" + t.area() + ",三角形的周长=" + t.perimeter());
System.exit(0);
}
}
习题六
1. 如何创建一个List或Set对象？使用它们存放数据时哪种对象不能存放重复元素？
【答】：
可以使用关键字new调用相应构造函数创建List或Set对象。
（1）要创建Lis
t对象时可使用以下方法：List
arraylist = new ArrayList();或 LinkedList linkedlist = new LinkedList();等等。
（2）要创建Set对象则调用相应的构造函数：HashSet hashset = new HashSet(); 等。
Set定义的集合中不能包含相同的元素。
2. 列举几种可以遍历集合对象中元素的方法。
【答】：
可以使用Iterator接口定义的方法来遍历类集，或直接使用循环语句来对集合中对象进
行遍历。
3. 如何向一个HashMap对象中添加元素？
【答】：
通过调用Map接口中定义好的put（）方法可以该对象中添加相应的元素，该方法原型
为Object put(Object key, Object value)。
如若已经建立了一个HashMap对象hashmap，则可使用hashmap.put(“关键字”，“元素
值”)来向hashmap对象添加元素及该元素的值。
4. 使用本章介绍的一种集合类型编写程序，实现从控制台任意输入若干名字，如Mike、
Jone、Benny……，将它们以字典序按升序方式输出。
【答】：
package javabook.answer.ch06;
import java.util.*;
import java.io.*;
public class ch6exe4 {
public static void main(String[] args) throws IOException{
List
System.out.println("请输入若干学生姓名（输入'exit'则终止输入）：");
BufferedReader buf = new BufferedReader (new InputStreamReader(System.in));
String str = buf.readLine();
while(!str.equals("exit")){
list.add(str);
str = buf.readLine();
}
buf.close();
Collections.sort(list);
System.out.println("您输入的学生有（按字典序排列）:");
Iterator i=list.iterator();
while(i.hasNext()){
String t=(String)i.next();
System.out.println(t);
}
}
}
5. 从下面文本中计算单词“Java”、“language”、“simple”的出现次数，并按次数从
大到小输出结果。文本内容为：
Java is certainly a good programming language. Java was never just a language.
Java is a whole platform. Java has a lot of nice language features. Java 2D was
designed so that simple operations are simple and complex operations are feasible.
【答】：
package javabook.answer.ch06;
import java.util.*;
public class ch6exe5 {
public static void main(String[] args){
String text="Java is certainly a good programming language. "+
"Java was never just a language. Java is a whole platform. "+
"Java has a lot of nice language features. "+
"Java 2D was designed so that simple operations are simple and complex operations are feasible.";
int count=0;
int flag[]={0,0,0};
Map hashMap=new HashMap();
StringTokenizer st=new StringTokenizer(text,". ");
String key[]={"Java","language","simple"};
whi
le(st.hasMoreTokens()){
String k=st.nextToken();
for(int i=0;i<3;i++){
if(k.equals(key[i])){
flag[i]=1;
if(hashMap.get(k)!=null){
count=((Integer)hashMap.get(k)).intValue();
count++;
hashMap.put(k, new Integer(count));
}
else{
hashMap.put(k, new Integer(1));
}
}
}
}
for(int i=0;i<3;i++){
if(flag[i]==0)
hashMap.put(key[i], new Integer(0));
}
Map map=new TreeMap(hashMap);
Set set=map.entrySet();
Iterator iterator=set.iterator();
System.out.println("待统计的文本为：");
System.out.println(text);
System.out.println("以下为要统计的单词及出现的次数(按次数从高到低排列)：");
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
6. 编写程序实现对任意消息窗口中输入的整数，输出该整数的所有因子。请使用Stack
类来存放因子，并在程序中使用本章中介绍的泛型指定Stack对象存储的元素类型。
【答】：
package javabook.answer.ch06;
import java.util.*;
import javax.swing.JOptionPane;
public class ch6exe6 {
public static void main(String[] args){
Stack
String s;
s=JOptionPane.showInputDialog("请输入一个整数：");
int n=Integer.parseInt(s);
for(int i=1;i<=n;i++){
if(n%i==0)
stack.push(i);
}
String str="整数"+s+"的因子有：\n";
while(!stack.empty()){
int i=stack.pop();
str+=i+"\n";
}
JOptionPane.showMessageDialog(null,str,"显示输入整数的因子
",https://www.doczj.com/doc/0510298717.html,RMATION_MESSAGE);
}
}
}
7. 编写一个Applet，显示当前日期和时间。显示的文字颜色、字体、大小均在HTML
文件中定义。
提示：可以使用java.util包中的Calendar类，该类提供了年、月、日、小时、分、秒等
信息，可以使用int get(int calendarField)方法来返回由参数calendarField指定的分量值，如
若实参为Calendar.YEAR，则该方法将返回当前的年份。因此可通过calendarField指定的分
量Calendar.YEAR、Calendar.MONTH、Calendar.DATE、Calendar.HOUR、Calendar.MINUTE
和Calendar.SECOND调用get()方法来取得当前的日期和时间。
【答】：
//题7程序源代码ch6exe7.java
package javabo
ok.answer.ch06;
import java.awt.*;
import java.applet.*;
import java.util.*;
import java.text.*;
public class ch6exe7 extends Applet {
String msg,font,nowdate,nowtime;
int x,y,fontcolor,size;
public void init() {
msg = getParameter("message");
x = Integer.parseInt(getParameter("X_Position"));
y = Integer.parseInt(getParameter("Y_Position"));
fontcolor = Integer.parseInt(getParameter("fontcolor"),16);
font = getParameter("font");
size = Integer.parseInt(getParameter("size"));
SimpleDateFormat fomatter1=new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat fomatter2=new SimpleDateFormat("hh:mm:ss");
Date date=new Date();
nowdate=fomatter1.format(date);
nowtime=fomatter2.format(date);
}
public void paint(Graphics g) {
Font f = new Font(font,Font.BOLD,size);
g.setFont(f);
g.setColor(new Color(fontcolor));
g.drawString("Today is: "+nowdate,50,40);
g.drawString("Now the time is: "+nowtime,50,70);
}
}
习题七
1． 什么是图形上下文，在Java2和Java2D中，如何实现对图形上下文的管理？
【答】：
图形上下文有时也称为图形环境，指允许用户在屏幕绘制图形的信息，它由Graphics
类封装，可以通过Component类的getGraphics（）方法返回获得。图形上下文表示一个绘
制图层，如组件的显示区、打印机上的一页、或一个屏幕外图像缓冲区。它提供了绘制三种
图形对象的方法：形状、文本和图像。
在Java中，可以通过Graphics的对象对图形上下文进行管理。
2． Graphics2D的属性有哪些，分别实现什么功能？
【答】：
Graphics 2D对象有6种属性，包括paint、stroke、font、transform、clip和composite。
（1）paint——该属性确定所绘制线条的颜色，以及填充图形的颜色和图案等。
（2）stroke——该属性可以确定线条的类型以及粗细，还有线段端点的形状。
（3）font——该属性可以确定所显示字符串的字体。
（4）transform——该属性确定了图形绘制过程中要应用的转换方法，通过指定转换方
法可将所画内容进行平移、旋转和缩放
（5）clip——该属性定义了组件上某区域的边界。
（6）composite——该属性定义了如何绘制重叠的几何图形，使用合成规则可以确定重
叠区域的显示效果。
3． 编写程序，使用柱形显示以下信息：90～100：10人（用蓝色矩形表示），80～90：
20人（用灰色矩形表示），70～80：40人（用绿色矩形表示），60～70：20人（用橙色矩形
表示），60以下：10人（用红色矩形表示）。程序结果如图7-18所示。
图7-18 第3题程序显示结果
【答】：
package javabook.answer.ch07;
import java.awt.*;
i
mport java.awt.geom.*;
import javax.swing.*;
public class ch7exe3 extends JFrame{
public ch7exe3() {
super();
setTitle("Exercise 7.3");
setSize(500,300);
setVisible(true);
}
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
Line2D l = new Line2D.Double(50,250,450,250);
g2.draw(l);
Rectangle2D r1 = new Rectangle2D.Double(100,200,60,50);
g2.setColor(Color.blue);
g2.fill(r1);
Rectangle2D r2 = new Rectangle2D.Double(160,150,60,100);
g2.setColor(Color.gray);
g2.fill(r2);
Rectangle2D r3 = new Rectangle2D.Double(220,50,60,200);
g2.setColor(Color.green);
g2.fill(r3);
Rectangle2D r4 = new Rectangle2D.Double(280,150,60,100);
g2.setColor(Color.orange);
g2.fill(r4);
Rectangle2D r5 = new Rectangle2D.Double(340,200,60,50);
g2.setColor(Color.red);
g2.fill(r5);
g2.setColor(Color.black);
g2.drawString("90～100",105,270);
g2.drawString("10人",115,190);
g2.drawString("80～90",170,270);
g2.drawString("20人",175,140);
g2.drawString("70～80",230,270);
g2.drawString("40人",235,40);
g2.drawString("60～70",290,270);
g2.drawString("20人",295,140);
g2.drawString("60以下",350,270);
g2.drawString("10人",355,190);
}
public static void main(String[] args) {
ch7exe3 e = new ch7exe3();
e.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
4． 编写程序，使用扇形图显示以下信息：90～100：10％，80～90：20％，70～80：40％，60～70：20％，60以下：10％。程序结果如图7-19所示。
图7-19第4题程序显示结果
【答】：
package javabook.answer.ch07;
import java.awt.*;
import java.awt.geom.*;
import javax.swing.*;
public class ch7exe4 extends JFrame{
public ch7exe4() {
super();
setTitle("Exercise 7.4");
setSize(300,300);
setVisible(true);
}
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
int x = getWidth()/2;
int y = getHeight()/2;
Arc2D r1 = new Arc2D.Double(x-120,y-120,240,240,0,36,Arc2D.PIE);
g2.setColor(Color.magenta);
g2.fill(r1);
Arc2D r2 = new Arc2D.Double(x-120,y-120,240,240,36,72,Arc2D.PIE);
g2.setColor(Color.LIGHT_GRAY);
g2.fill(r2);
Arc2D r3 = new Arc2D.Double(x-120,y-120,240,240,108,144,Arc2D.PIE);
g2.setColor(Color.green);
g2.fill(r3);
Arc2D r4 = new Arc2D.Double(x-120,y-120,240,240,252,72,Arc2D.PIE);
g2.setColor(Color.orange);
g2.fill(r4);
Arc2D r5 = new Arc2D.Double(x-120,y-120,240,240,324,36,Arc2D.PIE);
g2.setColor(Color.red);
g2.fill(r5);
g2.setColor(Color.black);
g2.drawString("90～100：10%",200,135);
g2.drawString("80～90：20%",150,80);
g2.drawString("70～80：40%",50,145);
g2.draw
String("60～70：20%",150,230);
g2.drawString("60以下：10%",200,175);
}
public static void main(String[] args) {
ch7exe4 e = new ch7exe4();
e.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
5． 使用Graphics2D绘制静止时钟的钟面，要求绘制出整点刻度以及时钟的时针和分针
且时钟显示为3点30分。
【答】：
package javabook.answer.ch07;
import java.awt.*;
import javax.swing.*;
public class ch7exe5 extends JFrame{
public ch7exe5() {
super();
setTitle("Ch7 Exercise 5");
setSize(300,200);
setVisible(true);
}
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
int x=150,y=100,radius=70;
g2.drawOval(80, 30, 140, 140);
g2.drawString("12", 145, 42);
g2.drawString("11", (int)(x-radius*Math.cos(2*Math.PI/6)),
(int)(y-radius*Math.sin(2*Math.PI/6)+10));
g2.drawString("10", (int)(x-radius*Math.cos(Math.PI/6)), (int)(y-radius*Math.sin(Math.PI/6))+10);
g2.drawString("9", 83, 105);
g2.drawString("8", (int)(x-radius*Math.cos(Math.PI/6)+5), (int)(y+radius*Math.sin(Math.PI/6)));
g2.drawString("7", (int)(x-radius*Math.cos(2*Math.PI/6)), (int)(y+radius*Math.sin(2*Math.PI/6)));
g2.drawString("6", 147, 167);
g2.drawString("5", (int)(x+radius*Math.cos(2*Math.PI/6)-10),
(int)(y+radius*Math.sin(2*Math.PI/6)));
g2.drawString("4", (int)(x+radius*Math.cos(Math.PI/6)-10), (int)(y+radius*Math.sin(Math.PI/6)));
g2.drawString("3", 210, 103);
g2.drawString("2", (int)(x+radius*Math.cos(Math.PI/6)-10), (int)(y-radius*Math.sin(Math.PI/6)+10));
g2.drawString("1", (int)(x+radius*Math.cos(2*Math.PI/6)-10),
(int)(y-radius*Math.sin(2*Math.PI/6))+10);
int ml=45;
int xm=(int)(x+ml*Math.sin(30*2*Math.PI/60));
int ym=(int)(y-ml*Math.cos(30*2*Math.PI/60));
g2.drawLine(x, y, xm, ym);
int hl=35;
int xh=(int)(x+hl*Math.sin(3.5*2*Math.PI/12));
int yh=(int)(y-hl*Math.cos(3.5*2*Math.PI/12));
g2.drawLine(x, y, xh, yh);
}
public static void main(String[] args) {
ch7exe5 c = new ch7exe5();
c.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
6． 使用Graphics2D绘制一个立方体和六边形，并使用渐变填充方式填充立方体，使用
纹理填充方式填充六边形，且六边形的外边框轮廓宽度为5
【答】：
package javabook.answer.ch07;
import java.awt.*;
import java.awt.geom.*;
import java.awt.image.BufferedImage;
import javax.swing.*;
public class ch7exe6 extends JFrame{
public ch7exe6() {
super();
setTitle("Ch7 Exercise 6");
setSize(300,200);
setVisible(true);
}
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
Rectangle2D r = new Rectangle2D.Float(20, 80, 100, 100);
g2.draw(r);
GeneralPath path1 = new GeneralP
ath();
path1.moveTo(20, 80);
path1.lineTo(40, 45);
path1.lineTo(140, 45);
path1.lineTo(120, 80);
path1.lineTo(20, 80);
g2.draw(path1);
GeneralPath path2 = new GeneralPath();
path2.moveTo(120, 80);
path2.lineTo(120, 180);
path2.lineTo(140, 145);
path2.lineTo(140, 45);
path2.lineTo(120, 80);
g2.draw(path2);
Point2D p1 = new Point2D.Double(20,80);
Point2D p2 = new Point2D.Double(70,130);
GradientPaint gp = new GradientPaint(p1, Color.white, p2, Color.black, true);
g2.setPaint(gp);
g2.fill(r);
p1 = new Point2D.Double(20,80);
p2 = new Point2D.Double(80,60);
gp = new GradientPaint(p1, Color.white, p2, Color.black, true);
g2.setPaint(gp);
g2.fill(path1);
p1 = new Point2D.Double(140,45);
p2 = new Point2D.Double(130,112.5);
gp = new GradientPaint(p1, Color.white, p2, Color.black, true);
g2.setPaint(gp);
g2.fill(path2);
GeneralPath path3 = new GeneralPath();
path3.moveTo(290, 100);
path3.lineTo((230+60*Math.cos(2*Math.PI/6)), (100-60*Math.sin(2*Math.PI/6)));
path3.lineTo((230+60*Math.cos(2*2*Math.PI/6)), (100-60*Math.sin(2*2*Math.PI/6)));
path3.lineTo((230+60*Math.cos(3*2*Math.PI/6)), (100-60*Math.sin(3*2*Math.PI/6)));
path3.lineTo((230+60*Math.cos(4*2*Math.PI/6)), (100-60*Math.sin(4*2*Math.PI/6)));
path3.lineTo((230+60*Math.cos(5*2*Math.PI/6)), (100-60*Math.sin(5*2*Math.PI/6)));
path3.lineTo(290, 100);
Stroke stroke = new BasicStroke(5.0f);
g2.setStroke(stroke);
g2.setColor(Color.black);
g2.draw(path3);
BufferedImage image=new BufferedImage(10,10,BufferedImage.TYPE_INT_RGB);
Graphics2D bg = image.createGraphics();
bg.setColor(Color.yellow);
bg.fillOval(0,0,5,5);
bg.setColor(Color.red);
bg.fillOval(0,5,5,5);
bg.setColor(Color.green);
bg.fillOval(5,0,5,5);
bg.setColor(Color.blue);
bg.fillOval(5,5,5,5);
Rectangle2D r1 = new Rectangle2D.Double(0,0,10,10);
TexturePaint tp = new TexturePaint(image,r1);
g2.setPaint(tp);
g2.fill(path3);
}
public static void main(String[] args) {
ch7exe6 c = new ch7exe6();
c.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
习 题 八
1．AWT包的GUI组件和Swing包的GUI组件有哪些不同？
【答】：
Swing包和AWT包的GUI具有类似的组件，不同之处在于：与AWT的GUI组件相比，
Swing是轻量级元件。SWING 提供许多比AWT更好的屏幕显示元素。它们用纯Java写成，
所以同Java本身一样可以跨平台运行。
2．什么是重量级组件？什么是轻量级组件？二者的区别是什么？
【答】：
依靠本地方法实现功能的组件称为重量级组件，而反之为轻量级的组件。二者的区别
判断的依据是否是依赖本地方法。
3．什么是MVC模式？请举
例说明。
【答】：
MVC是一种设计模式，M表示Model，说明业务模型，也就是组件的状态和行为，V
表示View视图，处理用户界面的显示；C表示Controller控制器，用来控制用户输入。例
如：javax.swing.JButton的组件实例中，一个JButton按钮组件中Model说明了该按钮的状
态、操作内部状态、添加删除监听事件、发生的事件；按钮的视图和控制器由一个接口
ButtonUI完成。如果一个类实现了这个接口，那么它将会负责创建一个用户界面，处理用户
的操作。涉及的方法可以被分为三大类：绘制Paint、返回几何类型的信息和处理事件。
4．编写一个Java程序，实现用户密码输入界面。
【答】：
实现用户密码输入的界面见下列程序。
package javabook.answer.ch08;
import javax.swing.*;
import java.awt.*;
public class EX4 extends JFrame {
JLabel userLabel;
JTextField userText;
JLabel passwordLabel;
JPasswordField password;
JButton confirmBtn;
public EX4() {
super("密码输入");
userLabel = new JLabel("用户名：");
passwordLabel = new JLabel("密码：");
userText = new JTextField(10);
password = new JPasswordField(10);
confirmBtn = new JButton("确认");
Container container = getContentPane();
container.setLayout(new FlowLayout());
container.add(userLabel);
container.add(userText);
container.add(passwordLabel);
container.add(password);
container.add(confirmBtn);
pack();
setVisible(true);
try {
UIManager
.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
SwingUtilities.updateComponentTreeUI(this);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, this);
}
}
public static void main(String args[]) {
EX4 cpf = new EX4();
cpf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
5．编写一个Java程序Counter.java，实现一个计算机器的图形界面。
【答】：
Counter.java的程序见下列代码：
package javabook.answer.ch08;
import java.awt.*;
import javax.swing.*;
public class EX5 extends JFrame {
private Container container;
private GridBagLayout layout;
private GridBagConstraints constraints;
private JTextField displayField;// 计算结果显示区
public EX5() {// 构造方法，定义所有GUI组件
super("Counter");
container = getContentPane();
layout = new GridBagLayout();
container.setLayout(layout);
constraints = new GridBagConstraints();
displayField = new JTextField(20);
displayField.setHorizontalAlignment(JTextField.RIGHT);
constraints.gridx = 0;
constraints.gridy = 0;
constraints.gridwidth = 4;
constraints.gridheight = 1;
constraints.fill = GridBagCons
traints.BOTH;
constraints.weightx = 100;
constraints.weighty = 100;
layout.setConstraints(displayField, constraints);
container.add(displayField);
addButton("Backspace", 0, 1, 2, 1);
addButton("CE", 2, 1, 1, 1);
addButton("C", 3, 1, 1, 1);
addButton("7", 0, 2, 1, 1);
addButton("8", 1, 2, 1, 1);
addButton("9", 2, 2, 1, 1);
addButton("/", 3, 2, 1, 1);
addButton("4", 0, 3, 1, 1);
addButton("5", 1, 3, 1, 1);
addButton("6", 2, 3, 1, 1);
addButton("*", 3, 3, 1, 1);
addButton("1", 0, 4, 1, 1);
addButton("2", 1, 4, 1, 1);
addButton("3", 2, 4, 1, 1);
addButton("-", 3, 4, 1, 1);
addButton("0", 0, 5, 1, 1);
addButton(" /-", 1, 5, 1, 1);
addButton(".", 2, 5, 1, 1);
addButton(" ", 3, 5, 1, 1);
addButton("=", 0, 6, 4, 1);
setSize(300, 300);
setVisible(true);
}
private void addButton(String label, int row, int column, int with,
int height) {// 定义按钮
JButton button = new JButton(label);
constraints.gridx = row;
constraints.gridy = column;
constraints.gridwidth = with;
constraints.gridheight = height;
constraints.fill = GridBagConstraints.BOTH;
layout.setConstraints(button, constraints);
container.add(button);
}
public static void main(String[] args) {// 主程序
EX5 Counter = new EX5();
Counter.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
6．编写一个Java程序FileMenu.java，设计一个简易文件管理菜单。菜单有文件、编辑
和帮助3项。其中文件菜单项有以下子菜单项：新建、打开、关闭、退出；编辑菜单项有以
下菜单项；复制、粘贴、查找、替换、定位；帮助菜单项有以下子菜单项：拥护帮助、版本
说明，采用windows操作系统的外观。
【答】：
FileMenu.java的源程序清单见下列代码：
package javabook.answer.ch08;
import javax.swing.*;
public class EX6 extends JFrame {
public EX6() {
super("文件简易菜单");
defineMenu();
setJMenuBar(menuBar);
setVisible(true);
setSize(400, 300);
}
private void defineMenu() {
menuBar = new JMenuBar();
menuBar.setToolTipText("FMS文件处理系统1.0");
fileMenu = new JMenu("文件(F)");// 定义文件菜单
fileMenu.setMnemonic('F');
newItem = new JMenuItem("新建");
openItem = new JMenuItem("打开");
closeItem = new JMenuItem("关闭");
exitItem = new JMenuItem("退出");
fileMenu.add(newItem);
fileMenu.add(openItem);
fileMenu.add(closeItem);
fileMenu.add(exitItem);
editMenu = new JMenu("编辑(E)");
editMenu.setMnemonic('E');
copyItem = new JMenuItem("复制");
pasteItem = new JMenuItem("粘贴");
searchItem = new JMenuItem("查找");
replaceItem = new JMenuItem("替换");
locateItem =
new JMenuItem("定位");
editMenu.add(copyItem);
editMenu.add(pasteItem);
editMenu.add(searchItem);
editMenu.add(replaceItem);
editMenu.add(locateItem);
helpMenu = new JMenu("帮助(H)");
helpMenu.setMnemonic('H');
userHelpItem = new JMenuItem("帮助");
versionItem = new JMenuItem("版本");
helpMenu.add(userHelpItem);
helpMenu.add(versionItem);
menuBar.add(fileMenu);
menuBar.add(editMenu);
menuBar.add(helpMenu);
}
public static void main(String args[]) {
EX6 fm = new EX6();
fm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
private JMenuBar menuBar;// 主菜单条
private JMenu fileMenu; // 文件菜单
private JMenu editMenu; // 编辑菜单
private JMenu helpMenu; // 系统帮助菜单
private JMenuItem newItem;// 文件新建；
private JMenuItem openItem;// 文件打开；
private JMenuItem closeItem;// 文件关闭;
private JMenuItem exitItem;// 文件退出；
private JMenuItem copyItem;// 文件复制；
private JMenuItem pasteItem;// 文件粘贴；
private JMenuItem searchItem;// 文件查找；
private JMenuItem replaceItem;// 文件替换；
private JMenuItem locateItem;// 文件定位；
private JMenuItem userHelpItem;// 用户帮助；
private JMenuItem versionItem;// 版本说明；
}
习 题 九
1．什么是代理事件处理模型？请举例说明。
【答】：
Java语言采用基于代理的事件处理模型。基于代理事件处理模型是引进了监听器接口，
每个事件类都有相关联的监听器接口。当用户对GUI组件有所动作，GUI组件会自动产生
相应的事件来响应用户的动作。假设这些GUI组件已经注册了相关的监听器对象，监听器
对象会一直监听已注册的组件对象是否有事件发生。当监听器对象监听到组件有相对应的事
件发生，就会调用监听器对象中方法，即事件处理器来实现一定的动作。就这样，通过对目
标监听器对象的相关Java方法调用，实现事件从事件源到监听者的传递。
2．常见的事件处理方式有哪几种？请比较各种方式的特点？
【答】：
有通过（1）实现监听器接口来处理事件、（2）利用独立监听器类实现事件处理、（3）
利用内部类实现事件处理、以及（4）利用匿名内部类实现事件处理四种事件处理方式。
方法（1）可直接对监听器接口的方法进行处理和调用，并且应用简单方便。但是，这
种方式存在一个问题，由于实现接口的方法和定义类的方法处于平行定义，如果要求对多个
组件有不同的处理，这种方法无疑会增加阅读程序的困难。
方法（2）事件处理的方式优点在于，处理事件的方法清晰明了，可读性强。另外