13.16 新型AWT

在Java 1.1中一个显著的改变就是完善了新AWT的创新。大多数的改变围绕在Java 1.1中使用的新事件模型：老的事件模型是糟糕的、笨拙的、非面向对象的，而新的事件模型可能是我所见过的最优秀的。难以理解一个如此糟糕的（老的AWT）和一个如此优秀的（新的事件模型）程序语言居然出自同一个集团之手。新的考虑事件的方法看来中止了，因此争议不再变成障碍，从而轻易进入我们的意识里；相反，它是一个帮助我们设计系统的工具。它同样是Java Beans的精华，我们会在本章后面部分进入讲述。

新的方法设计对象做为“事件源”和“事件接收器”以代替老AWT的非面向对象串联的条件语句。正象我们将看到的内部类的用途是集成面向对象的原始状态的新事件。另外，事件现在被描绘为在一个类体系以取代单一的类并且我们可以创建自己的事件类型。

我们同样会发现，如果我们采用老的AWT编程，Java 1.1版会产生一些看起来不合理的名字转换。例如，setsize()改成resize()。当我们学习Java Beans时这会变得更加的合理，因为Beans使用一个独特的命名协议。名字必须被修改以在Beans中产生新的标准AWT组件。

剪贴板操作在Java 1.1版中也得到支持，尽管拖放操作“将在新版本中被支持”。我们可能访问桌面色彩组织，所以我们的Java可以同其余桌面保持一致。可以利用弹出式菜单，并且为图像和图形作了改进。也同样支持鼠标操作。还有简单的为打印的API以及简单地支持滚动。

13.16.1 新的事件模型

在新的事件模型的组件可以开始一个事件。每种类型的事件被一个个别的类所描绘。当事件开始后，它受理一个或更多事件指明“接收器”。因此，事件源和处理事件的地址可以被分离。

每个事件接收器都是执行特定的接收器类型接口的类对象。因此作为一个程序开发者，我们所要做的是创建接收器对象并且在被激活事件的组件中进行注册。event-firing组件调用一个addXXXListener()方法来完成注册，以描述XXX事件类型接受。我们可以容易地了解到以addListened名的方法通知我们任何的事件类型都可以被处理，如果我们试图接收事件我们会发现编译时我们的错误。Java Beans同样使用这种addListener名的方法去判断那一个程序可以运行。

我们所有的事件逻辑将装入到一个接收器类中。当我们创建一个接收器类时唯一的一点限制是必须执行专用的接口。我们可以创建一个全局接收器类，这种情况在内部类中有助于被很好地使用，不仅仅是因为它们提供了一个理论上的接收器类组到它们服务的UI或业务逻辑类中，但因为（正像我们将会在本章后面看到的）事实是一个内部类维持一个句柄到它的父对象，提供了一个很好的通过类和子系统边界的调用方法。

一个简单的例子将使这一切变得清晰明确。同时思考本章前部Button2.java例子与这个例子的差异。

//: Button2New.java

// Capturing button presses

import java.awt.;

import java.awt.event.; // Must add this

import java.applet.;

public class Button2New extends Applet {

Button

b1 = new Button("Button 1"),

b2 = new Button("Button 2");

public void init() {

b1.addActionListener(new B1());

b2.addActionListener(new B2());

add(b1);

add(b2);

}

class B1 implements ActionListener {

public void actionPerformed(ActionEvent e) {

getAppletContext().showStatus("Button 1");

}

}

class B2 implements ActionListener {

public void actionPerformed(ActionEvent e) {

getAppletContext().showStatus("Button 2");

}

}

/ The old way:

public boolean action(Event evt, Object arg) {

if(evt.target.equals(b1))

getAppletContext().showStatus("Button 1");

else if(evt.target.equals(b2))

getAppletContext().showStatus("Button 2");

// Let the base class handle it:

else

return super.action(evt, arg);

return true; // We've handled it here

}

*/

} ///:~

我们可比较两种方法，老的代码在左面作为注解。在init()方法里，只有一个改变就是增加了下面的两行：

b1.addActionListener(new B1());

b2.addActionListener(new B2());

按钮按下时，addActionListener()通知按钮对象被激活。B1和B2类都是执行接口ActionListener的内部类。这个接口包括一个单一的方法actionPerformed()（这意味着当事件激活时，这个动作将被执行）。注意actionPreformed()方法不是一个普通事件，说得更恰当些是一个特殊类型的事件，ActionEvent。如果我们想提取特殊ActionEvent的信息，因此我们不需要故意去测试和下溯造型自变量。

对编程者来说一个最好的事便是actionPerformed()十分的简单易用。它是一个可以调用的方法。同老的action()方法比较，老的方法我们必须指出发生了什么和适当的动作，同样，我们会担心调用基础类action()的版本并且返回一个值去指明是否被处理。在新的事件模型中，我们知道所有事件测试推理自动进行，因此我们不必指出发生了什么；我们刚刚表示发生了什么，它就自动地完成了。如果我们还没有提出用新的方法覆盖老的方法，我们会很快提出。

13.16.2 事件和接收者类型

所有AWT组件都被改变成包含addXXXListener()和removeXXXListener()方法，因此特定的接收器类型可从每个组件中增加和删除。我们会注意到“XXX”在每个场合中同样表示自变量的方法，例如，addFooListener(FooListener fl)。下面这张表格总结了通过提供addXXXListener()和removeXXXListener()方法，从而支持那些特定事件的相关事件、接收器、方法以及组件。

事件，接收器接口及添加和删除方法 支持这个事件的组件

⑤：即使表面上如此，但实际上并没有MouseMotiionEvent（鼠标运动事件）。单击和运动都合成到MouseEvent里，所以MouseEvent在表格中的这种另类行为并非一个错误。

可以看到，每种类型的组件只为特定类型的事件提供了支持。这有助于我们发现由每种组件支持的事件，如下表所示：

组件类型 支持的事件

一旦知道了一个特定的组件支持哪些事件，就不必再去寻找任何东西来响应那个事件。只需简单地：

(1) 取得事件类的名字，并删掉其中的“Event”字样。在剩下的部分加入“Listener”字样。这就是在我们的内部类里需要实现的接收器接口。

(2) 实现上面的接口，针对想要捕获的事件编写方法代码。例如，假设我们想捕获鼠标的移动，所以需要为MouseMotiionListener接口的mouseMoved()方法编写代（当然还必须实现其他一些方法，但这里有捷径可循，马上就会讲到这个问题）。

(3) 为步骤2中的接收器类创建一个对象。随自己的组件和方法完成对它的注册，方法是在接收器的名字里加入一个前缀“add”。比如addMouseMotionListener()。

下表是对接收器接口的一个总结：

接收器接口 接口中的方法

1. 用接收器适配器简化操作

在上面的表格中，我们可以注意到一些接收器接口只有唯一的一个方法。它们的执行是无轻重的，因为我们仅当需要书写特殊方法时才会执行它们。然而，接收器接口拥有多个方法，使用起来却不太友好。例如，我们必须一直运行某些事物，当我们创建一个应用程序时对帧提供一个WindowListener，以便当我们得到windowClosing()事件时可以调用System.exit(0)以退出应用程序。但因为WindowListener是一个接口，我们必须执行其它所有的方法即使它们不运行任何事件。这真令人讨厌。

为了解决这个问题，每个拥有超过一个方法的接收器接口都可拥有适配器，它们的名我们可以在上面的表格中看到。每个适配器为每个接口方法提供默认的方法。（WindowAdapter的默认方法不是windowClosing()，而是System.exit(0)方法。）此外我们所要做的就是从适配器处继承并过载唯一的需要变更的方法。例如，典型的WindowListener我们会像下面这样的使用。

class MyWindowListener extends WindowAdapter {

public void windowClosing(WindowEvent e) {

System.exit(0);

}

}

适配器的全部宗旨就是使接收器的创建变得更加简便。

但所谓的“适配器”也有一个缺点，而且较难发觉。假定我们象上面那样写一个WindowAdapter：

class MyWindowListener extends WindowAdapter {

public void WindowClosing(WindowEvent e) {

System.exit(0);

}

}

表面上一切正常，但实际没有任何效果。每个事件的编译和运行都很正常——只是关闭窗口不会退出程序。您注意到问题在哪里吗？在方法的名字里：是WindowClosing()，而不是windowClosing()。大小写的一个简单失误就会造成一个崭新的方法。但是，这并非我们关闭窗口时调用的方法，所以当然没有任何效果。

13.16.3 用Java 1.1 AWT制作窗口和程序片

我们经常都需要创建一个类，使其既可作为一个窗口调用，亦可作为一个程序片调用。为做到这一点，只需为程序片简单地加入一个main()即可，令其在一个Frame（帧）里构建程序片的一个实例。作为一个简单的示例，下面让我们来看看如何对Button2New.java作一番修改，使其能同时作为应用程序和程序片使用：

//: Button2NewB.java

// An application and an applet

import java.awt.;

import java.awt.event.; // Must add this

import java.applet.*;

public class Button2NewB extends Applet {

Button

b1 = new Button("Button 1"),

b2 = new Button("Button 2");

TextField t = new TextField(20);

public void init() {

b1.addActionListener(new B1());

b2.addActionListener(new B2());

add(b1);

add(b2);

add(t);

}

class B1 implements ActionListener {

public void actionPerformed(ActionEvent e) {

t.setText("Button 1");

}

}

class B2 implements ActionListener {

public void actionPerformed(ActionEvent e) {

t.setText("Button 2");

}

}

// To close the application:

static class WL extends WindowAdapter {

public void windowClosing(WindowEvent e) {

System.exit(0);

}

}

// A main() for the application:

public static void main(String[] args) {

Button2NewB applet = new Button2NewB();

Frame aFrame = new Frame("Button2NewB");

aFrame.addWindowListener(new WL());

aFrame.add(applet, BorderLayout.CENTER);

aFrame.setSize(300,200);

applet.init();

applet.start();

aFrame.setVisible(true);

}

} ///:~

内部类WL和main()方法是加入程序片的唯一两个元素，程序片剩余的部分则原封未动。事实上，我们通常将WL类和main()方法做一结小的改进复制和粘贴到我们自己的程序片里（请记住创建内部类时通常需要一个外部类来处理它，形成它静态地消除这个需要）。我们可以看到在main()方法里，程序片明确地初始化和开始，因为在这个例子里浏览器不能为我们有效地运行它。当然，这不会提供全部的浏览器调用stop()和destroy()的行为，但对大多数的情况而言它都是可接受的。如果它变成一个麻烦，我们可以：

(1) 使程序片句柄为一个静态类（以代替局部可变的main()），然后：

(2) 在我们调用System.exit()之前在WindowAdapter.windowClosing()中调用applet.stop()和applet.destroy()。

注意最后一行：

aFrame.setVisible(true);

这是Java 1.1 AWT的一个改变。show()方法不再被支持，而setVisible(true)则取代了show()方法。当我们在本章后面部分学习Java Beans时，这些表面上易于改变的方法将会变得更加的合理。

这个例子同样被使用TextField修改而不是显示到控制台或浏览器状态行上。在开发程序时有一个限制条件就是程序片和应用程序我们都必须根据它们的运行情况选择输入和输出结构。

这里展示了Java 1.1 AWT的其它小的新功能。我们不再需要去使用有错误倾向的利用字符串指定BorderLayout定位的方法。当我们增加一个元素到Java 1.1版的BorderLayout中时，我们可以这样写：

aFrame.add(applet, BorderLayout.CENTER);

我们对位置规定一个BorderLayout的常数，以使它能在编译时被检验（而不是对老的结构悄悄地做不合适的事）。这是一个显著的改善，并且将在这本书的余下部分大量地使用。

1. 将窗口接收器变成匿名类

任何一个接收器类都可作为一个匿名类执行，但这一直有个意外，那就是我们可能需要在其它场合使用它们的功能。但是，窗口接收器在这里仅作为关闭应用程序窗口来使用，因此我们可以安全地制造一个匿名类。然后，main()中的下面这行代码：

aFrame.addWindowListener(new WL());

会变成：

aFrame.addWindowListener(

new WindowAdapter() {

public void windowClosing(WindowEvent e) {

System.exit(0);

}

});

这有一个优点就是它不需要其它的类名。我们必须对自己判断是否它使代码变得易于理解或者更难。不过，对本书余下部分而言，匿名内部类将通常被使用在窗口接收器中。

1. 将程序片封装到JAR文件里

一个重要的JAR应用就是完善程序片的装载。在Java 1.0版中，人们倾向于试法将它们的代码填入到单个的程序片类里，因此客户只需要单个的服务器就可适合下载程序片代码。但这不仅使结果凌乱，难以阅读（当然维护也然）程序，但类文件一直不能压缩，因此下载从来没有快过。

JAR文件将我们所有的被压缩的类文件打包到一个单个儿的文件中，再被浏览器下载。现在我们不需要创建一个糟糕的设计以最小化我们创建的类，并且用户将得到更快地下载速度。

仔细想想上面的例子，这个例子看起来像Button2NewB，是一个单类，但事实上它包含三个内部类，因此共有四个。每当我们编译程序，我会用这行代码打包它到一个JAR文件：

jar cf Button2NewB.jar *.class

这是假定只有一个类文件在当前目录中，其中之一来自Button2NewB.java（否则我们会得到特别的打包）。

现在我们可以创建一个使用新文件标签来指定JAR文件的HTML页，如下所示：

<head><title>Button2NewB Example Applet

</title></head>

<body>

<applet code="Button2NewB.class"

archive="Button2NewB.jar"

width=200 height=150>

</applet>

</body>

与HTML文件中的程序片标记有关的其他任何内容都保持不变。

13.16.4 再研究一下以前的例子

为注意到一些利用新事件模型的例子和为学习程序从老到新事件模型改变的方法，下面的例子回到在本章第一部分利用事件模型来证明的一些争议。另外，每个程序包括程序片和应用程序现在都可以借助或不借助浏览器来运行。

1. 文本字段

这个例子同TextField1.java相似，但它增加了显然额外的行为：

//: TextNew.java

// Text fields with Java 1.1 events

import java.awt.;

import java.awt.event.;

import java.applet.*;

public class TextNew extends Applet {

Button

b1 = new Button("Get Text"),

b2 = new Button("Set Text");

TextField

t1 = new TextField(30),

t2 = new TextField(30),

t3 = new TextField(30);

String s = new String();

public void init() {

b1.addActionListener(new B1());

b2.addActionListener(new B2());

t1.addTextListener(new T1());

t1.addActionListener(new T1A());

t1.addKeyListener(new T1K());

add(b1);

add(b2);

add(t1);

add(t2);

add(t3);

}

class T1 implements TextListener {

public void textValueChanged(TextEvent e) {

t2.setText(t1.getText());

}

}

class T1A implements ActionListener {

private int count = 0;

public void actionPerformed(ActionEvent e) {

t3.setText("t1 Action Event " + count++);

}

}

class T1K extends KeyAdapter {

public void keyTyped(KeyEvent e) {

String ts = t1.getText();

if(e.getKeyChar() ==

KeyEvent.VK_BACK_SPACE) {

// Ensure it's not empty:

if( ts.length() > 0) {

ts = ts.substring(0, ts.length() - 1);

t1.setText(ts);

}

}

else

t1.setText(

t1.getText() +

Character.toUpperCase(

e.getKeyChar()));

t1.setCaretPosition(

t1.getText().length());

// Stop regular character from appearing:

e.consume();

}

}

class B1 implements ActionListener {

public void actionPerformed(ActionEvent e) {

s = t1.getSelectedText();

if(s.length() == 0) s = t1.getText();

t1.setEditable(true);

}

}

class B2 implements ActionListener {

public void actionPerformed(ActionEvent e) {

t1.setText("Inserted by Button 2: " + s);

t1.setEditable(false);

}

}

public static void main(String[] args) {

TextNew applet = new TextNew();

Frame aFrame = new Frame("TextNew");

aFrame.addWindowListener(

new WindowAdapter() {

public void windowClosing(WindowEvent e) {

System.exit(0);

}

});

aFrame.add(applet, BorderLayout.CENTER);

aFrame.setSize(300,200);

applet.init();

applet.start();

aFrame.setVisible(true);

}

} ///:~

当TextField t1的动作接收器被激活时，TextField t3就是一个需要报告的场所。我们注意到仅当我们按下“enter”键时，动作接收器才会为“TextField”所激活。

TextField t1附有几个接收器。T1接收器从t1复制所有文字到t2，强制所有字符串转换成大写。我们会发现这两个工作同是进行的，并且如果我们增加T1K接收器后我们再增加T1接收器，它就不那么重要：在文字字段内的所有的字符串将一直被强制变为大写。这看起来键盘事件一直在文字组件事件前被激活，并且如果我们需要保留t2的字符串原来输入时的样子，我们就必须做一些特别的工作。

T1K有着其它的一些有趣的活动。我们必须测试backspace（因为我们现在控制着每一个事件）并执行删除。caret必须被明确地设置到字段的结尾；否则它不会像我们希望的运行。最后，为了防止原来的字符串被默认的机制所处理，事件必须利用为事件对象而存在的consume()方法所“耗尽”。这会通知系统停止激活其余特殊事件的事件处理器。

这个例子同样无声地证明了设计内部类的带来的诸多优点。注意下面的内部类：

class T1 implements TextListener {

public void textValueChanged(TextEvent e) {

t2.setText(t1.getText());

}

}

t1和t2不属于T1的一部分，并且到目前为止它们都是很容易理解的，没有任何的特殊限制。这是因为一个内部类的对象能自动地捕捉一个句柄到外部的创建它的对象那里，因此我们可以处理封装类对象的方法和内容。正像我们看到的，这十分方便（注释⑥）。

⑥：它也解决了“回调”的问题，不必为Java加入任何令人恼火的“方法指针”特性。

1. 文本区域

Java 1.1版中Text Area最重要的改变就滚动条。对于TextArea的构建器而言，我们可以立即控制TextArea是否会拥有滚动条：水平的，垂直的，两者都有或者都没有。这个例子更正了前面Java 1.0版TextArea1.java程序片，演示了Java 1.1版的滚动条构建器：

//: TextAreaNew.java

// Controlling scrollbars with the TextArea

// component in Java 1.1

import java.awt.;

import java.awt.event.;

import java.applet.*;

public class TextAreaNew extends Applet {

Button b1 = new Button("Text Area 1");

Button b2 = new Button("Text Area 2");

Button b3 = new Button("Replace Text");

Button b4 = new Button("Insert Text");

TextArea t1 = new TextArea("t1", 1, 30);

TextArea t2 = new TextArea("t2", 4, 30);

TextArea t3 = new TextArea("t3", 1, 30,

TextArea.SCROLLBARS_NONE);

TextArea t4 = new TextArea("t4", 10, 10,

TextArea.SCROLLBARS_VERTICAL_ONLY);

TextArea t5 = new TextArea("t5", 4, 30,

TextArea.SCROLLBARS_HORIZONTAL_ONLY);

TextArea t6 = new TextArea("t6", 10, 10,

TextArea.SCROLLBARS_BOTH);

public void init() {

b1.addActionListener(new B1L());

add(b1);

add(t1);

b2.addActionListener(new B2L());

add(b2);

add(t2);

b3.addActionListener(new B3L());

add(b3);

b4.addActionListener(new B4L());

add(b4);

add(t3); add(t4); add(t5); add(t6);

}

class B1L implements ActionListener {

public void actionPerformed(ActionEvent e) {

t5.append(t1.getText() + "\n");

}

}

class B2L implements ActionListener {

public void actionPerformed(ActionEvent e) {

t2.setText("Inserted by Button 2");

t2.append(": " + t1.getText());

t5.append(t2.getText() + "\n");

}

}

class B3L implements ActionListener {

public void actionPerformed(ActionEvent e) {

String s = " Replacement ";

t2.replaceRange(s, 3, 3 + s.length());

}

}

class B4L implements ActionListener {

public void actionPerformed(ActionEvent e) {

t2.insert(" Inserted ", 10);

}

}

public static void main(String[] args) {

TextAreaNew applet = new TextAreaNew();

Frame aFrame = new Frame("TextAreaNew");

aFrame.addWindowListener(

new WindowAdapter() {

public void windowClosing(WindowEvent e) {

System.exit(0);

}

});

aFrame.add(applet, BorderLayout.CENTER);

aFrame.setSize(300,725);

applet.init();

applet.start();

aFrame.setVisible(true);

}

} ///:~

我们发现只能在构造TextArea时能够控制滚动条。同样，即使TE AR没有滚动条，我们滚动光标也将被制止（可通过运行这个例子中验证这种行为）。

1. 复选框和单选钮

正如早先指出的那样，复选框和单选钮都是同一个类建立的。单选钮和复选框略有不同，它是复选框安置到CheckboxGroup中构成的。在其中任一种情况下，有趣的ItemEvent事件为我们创建一个ItemListener项目接收器。

当处理一组复选框或者单选钮时，我们有一个不错的选择。我们可以创建一个新的内部类去为每个复选框处理事件，或者创建一个内部类判断哪个复选框被单击并注册一个内部类单独的对象为每个复选对象。下面的例子演示了两种方法：

//: RadioCheckNew.java

// Radio buttons and Check Boxes in Java 1.1

import java.awt.;

import java.awt.event.;

import java.applet.*;

public class RadioCheckNew extends Applet {

TextField t = new TextField(30);

Checkbox[] cb = {

new Checkbox("Check Box 1"),

new Checkbox("Check Box 2"),

new Checkbox("Check Box 3") };

CheckboxGroup g = new CheckboxGroup();

Checkbox

cb4 = new Checkbox("four", g, false),

cb5 = new Checkbox("five", g, true),

cb6 = new Checkbox("six", g, false);

public void init() {

t.setEditable(false);

add(t);

ILCheck il = new ILCheck();

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

cb[i].addItemListener(il);

add(cb[i]);

}

cb4.addItemListener(new IL4());

cb5.addItemListener(new IL5());

cb6.addItemListener(new IL6());

add(cb4); add(cb5); add(cb6);

}

// Checking the source:

class ILCheck implements ItemListener {

public void itemStateChanged(ItemEvent e) {

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

if(e.getSource().equals(cb[i])) {

t.setText("Check box " + (i + 1));

return;

}

}

}

}

// vs. an individual class for each item:

class IL4 implements ItemListener {

public void itemStateChanged(ItemEvent e) {

t.setText("Radio button four");

}

}

class IL5 implements ItemListener {

public void itemStateChanged(ItemEvent e) {

t.setText("Radio button five");

}

}

class IL6 implements ItemListener {

public void itemStateChanged(ItemEvent e) {

t.setText("Radio button six");

}

}

public static void main(String[] args) {

RadioCheckNew applet = new RadioCheckNew();

Frame aFrame = new Frame("RadioCheckNew");

aFrame.addWindowListener(

new WindowAdapter() {

public void windowClosing(WindowEvent e) {

System.exit(0);

}

});

aFrame.add(applet, BorderLayout.CENTER);

aFrame.setSize(300,200);

applet.init();

applet.start();

aFrame.setVisible(true);

}

} ///:~

ILCheck拥有当我们增加或者减少复选框时自动调整的优点。当然，我们对单选钮使用这种方法也同样的好。但是，它仅当我们的逻辑足以普遍的支持这种方法时才会被使用。如果声明一个确定的信号——我们将重复利用独立的接收器类，否则我们将结束一串条件语句。

1. 下拉列表

下拉列表在Java 1.1版中当一个选择被改变时同样使用ItemListener去告知我们：

//: ChoiceNew.java

// Drop-down lists with Java 1.1

import java.awt.;

import java.awt.event.;

import java.applet.*;

public class ChoiceNew extends Applet {

String[] description = { "Ebullient", "Obtuse",

"Recalcitrant", "Brilliant", "Somnescent",

"Timorous", "Florid", "Putrescent" };

TextField t = new TextField(100);

Choice c = new Choice();

Button b = new Button("Add items");

int count = 0;

public void init() {

t.setEditable(false);

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

c.addItem(description[count++]);

add(t);

add(c);

add(b);

c.addItemListener(new CL());

b.addActionListener(new BL());

}

class CL implements ItemListener {

public void itemStateChanged(ItemEvent e) {

t.setText("index: " + c.getSelectedIndex()

+ " " + e.toString());

}

}

class BL implements ActionListener {

public void actionPerformed(ActionEvent e) {

if(count < description.length)

c.addItem(description[count++]);

}

}

public static void main(String[] args) {

ChoiceNew applet = new ChoiceNew();

Frame aFrame = new Frame("ChoiceNew");

aFrame.addWindowListener(

new WindowAdapter() {

public void windowClosing(WindowEvent e) {

System.exit(0);

}

});

aFrame.add(applet, BorderLayout.CENTER);

aFrame.setSize(750,100);

applet.init();

applet.start();

aFrame.setVisible(true);

}

} ///:~

这个程序中没什么特别新颖的东西（除了Java 1.1版的UI类里少数几个值得关注的缺陷）。

1. 列表

我们消除了Java 1.0中List设计的一个缺陷，就是List不能像我们希望的那样工作：它会与单击在一个列表元素上发生冲突。

//: ListNew.java

// Java 1.1 Lists are easier to use

import java.awt.;

import java.awt.event.;

import java.applet.*;

public class ListNew extends Applet {

String[] flavors = { "Chocolate", "Strawberry",

"Vanilla Fudge Swirl", "Mint Chip",

"Mocha Almond Fudge", "Rum Raisin",

"Praline Cream", "Mud Pie" };

// Show 6 items, allow multiple selection:

List lst = new List(6, true);

TextArea t = new TextArea(flavors.length, 30);

Button b = new Button("test");

int count = 0;

public void init() {

t.setEditable(false);

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

lst.addItem(flavors[count++]);

add(t);

add(lst);

add(b);

lst.addItemListener(new LL());

b.addActionListener(new BL());

}

class LL implements ItemListener {

public void itemStateChanged(ItemEvent e) {

t.setText("");

String[] items = lst.getSelectedItems();

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

t.append(items[i] + "\n");

}

}

class BL implements ActionListener {

public void actionPerformed(ActionEvent e) {

if(count < flavors.length)

lst.addItem(flavors[count++], 0);

}

}

public static void main(String[] args) {

ListNew applet = new ListNew();

Frame aFrame = new Frame("ListNew");

aFrame.addWindowListener(

new WindowAdapter() {

public void windowClosing(WindowEvent e) {

System.exit(0);

}

});

aFrame.add(applet, BorderLayout.CENTER);

aFrame.setSize(300,200);

applet.init();

applet.start();

aFrame.setVisible(true);

}

} ///:~

我们可以注意到在列表项中无需特别的逻辑需要去支持一个单击动作。我们正好像我们在其它地方所做的那样附加上一个接收器。

1. 菜单

为菜单处理事件看起来受益于Java 1.1版的事件模型，但Java生成菜单的方法常常麻烦并且需要一些手工编写代码。生成菜单的正确方法看起来像资源而不是一些代码。请牢牢记住编程工具会广泛地为我们处理创建的菜单，因此这可以减少我们的痛苦（只要它们会同样处理维护任务！）。另外，我们将发现菜单不支持并且将导致混乱的事件：菜单项使用ActionListeners（动作接收器），但复选框菜单项使用ItemListeners（项目接收器）。菜单对象同样能支持ActionListeners（动作接收器），但通常不那么有用。一般来说，我们会附加接收器到每个菜单项或复选框菜单项，但下面的例子（对先前例子的修改）演示了一个联合捕捉多个菜单组件到一个单独的接收器类的方法。正像我们将看到的，它或许不值得为这而激烈地争论。

//: MenuNew.java

// Menus in Java 1.1

import java.awt.;

import java.awt.event.;

public class MenuNew extends Frame {

String[] flavors = { "Chocolate", "Strawberry",

"Vanilla Fudge Swirl", "Mint Chip",

"Mocha Almond Fudge", "Rum Raisin",

"Praline Cream", "Mud Pie" };

TextField t = new TextField("No flavor", 30);

MenuBar mb1 = new MenuBar();

Menu f = new Menu("File");

Menu m = new Menu("Flavors");

Menu s = new Menu("Safety");

// Alternative approach:

CheckboxMenuItem[] safety = {

new CheckboxMenuItem("Guard"),

new CheckboxMenuItem("Hide")

};

MenuItem[] file = {

// No menu shortcut:

new MenuItem("Open"),

// Adding a menu shortcut is very simple:

new MenuItem("Exit",

new MenuShortcut(KeyEvent.VK_E))

};

// A second menu bar to swap to:

MenuBar mb2 = new MenuBar();

Menu fooBar = new Menu("fooBar");

MenuItem[] other = {

new MenuItem("Foo"),

new MenuItem("Bar"),

new MenuItem("Baz"),

};

// Initialization code:

{

ML ml = new ML();

CMIL cmil = new CMIL();

safety[0].setActionCommand("Guard");

safety[0].addItemListener(cmil);

safety[1].setActionCommand("Hide");

safety[1].addItemListener(cmil);

file[0].setActionCommand("Open");

file[0].addActionListener(ml);

file[1].setActionCommand("Exit");

file[1].addActionListener(ml);

other[0].addActionListener(new FooL());

other[1].addActionListener(new BarL());

other[2].addActionListener(new BazL());

}

Button b = new Button("Swap Menus");

public MenuNew() {

FL fl = new FL();

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

MenuItem mi = new MenuItem(flavors[i]);

mi.addActionListener(fl);

m.add(mi);

// Add separators at intervals:

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

m.addSeparator();

}

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

s.add(safety[i]);

f.add(s);

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

f.add(file[i]);

mb1.add(f);

mb1.add(m);

setMenuBar(mb1);

t.setEditable(false);

add(t, BorderLayout.CENTER);

// Set up the system for swapping menus:

b.addActionListener(new BL());

add(b, BorderLayout.NORTH);

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

fooBar.add(other[i]);

mb2.add(fooBar);

}

class BL implements ActionListener {

public void actionPerformed(ActionEvent e) {

MenuBar m = getMenuBar();

if(m == mb1) setMenuBar(mb2);

else if (m == mb2) setMenuBar(mb1);

}

}

class ML implements ActionListener {

public void actionPerformed(ActionEvent e) {

MenuItem target = (MenuItem)e.getSource();

String actionCommand =

target.getActionCommand();

if(actionCommand.equals("Open")) {

String s = t.getText();

boolean chosen = false;

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

if(s.equals(flavors[i])) chosen = true;

if(!chosen)

t.setText("Choose a flavor first!");

else

t.setText("Opening "+ s +". Mmm, mm!");

} else if(actionCommand.equals("Exit")) {

dispatchEvent(

new WindowEvent(MenuNew.this,

WindowEvent.WINDOW_CLOSING));

}

}

}

class FL implements ActionListener {

public void actionPerformed(ActionEvent e) {

MenuItem target = (MenuItem)e.getSource();

t.setText(target.getLabel());

}

}

// Alternatively, you can create a different

// class for each different MenuItem. Then you

// Don't have to figure out which one it is:

class FooL implements ActionListener {

public void actionPerformed(ActionEvent e) {

t.setText("Foo selected");

}

}

class BarL implements ActionListener {

public void actionPerformed(ActionEvent e) {

t.setText("Bar selected");

}

}

class BazL implements ActionListener {

public void actionPerformed(ActionEvent e) {

t.setText("Baz selected");

}

}

class CMIL implements ItemListener {

public void itemStateChanged(ItemEvent e) {

CheckboxMenuItem target =

(CheckboxMenuItem)e.getSource();

String actionCommand =

target.getActionCommand();

if(actionCommand.equals("Guard"))

t.setText("Guard the Ice Cream! " +

"Guarding is " + target.getState());

else if(actionCommand.equals("Hide"))

t.setText("Hide the Ice Cream! " +

"Is it cold? " + target.getState());

}

}

public static void main(String[] args) {

MenuNew f = new MenuNew();

f.addWindowListener(

new WindowAdapter() {

public void windowClosing(WindowEvent e) {

System.exit(0);

}

});

f.setSize(300,200);

f.setVisible(true);

}

} ///:~

在我们开始初始化节（由注解“Initialization code:”后的右大括号指明）的前面部分的代码同先前（Java 1.0版）版本相同。这里我们可以注意到项目接收器和动作接收器被附加在不同的菜单组件上。

Java 1.1支持“菜单快捷键”，因此我们可以选择一个菜单项目利用键盘替代鼠标。这十分的简单；我们只要使用过载菜单项构建器设置第二个自变量为一个MenuShortcut（菜单快捷键事件）对象即可。菜单快捷键构建器设置重要的方法，当它按下时不可思议地显示在菜单项上。上面的例子增加了Control-E到“Exit”

菜单项中。

我们同样会注意setActionCommand()的使用。这看似一点陌生因为在各种情况下“action command”完全同菜单组件上的标签一样。为什么不正好使用标签代替可选择的字符串呢？这个难题是国际化的。如果我们重新用其它语言写这个程序，我们只需要改变菜单中的标签，并不审查代码中可能包含新错误的所有逻辑。因此使这对检查文字字符串联合菜单组件的代码而言变得简单容易，当菜单标签能改变时“动作指令”可以不作任何的改变。所有这些代码同“动作指令”一同工作，因此它不会受改变菜单标签的影响。注意在这个程序中，不是所有的菜单组件都被它们的动作指令所审查，因此这些组件都没有它们的动作指令集。

大多数的构建器同前面的一样，将几个调用的异常增加到接收器中。大量的工作发生在接收器里。在前面例子的BL中，菜单交替发生。在ML中，“寻找ring”方法被作为动作事件（ActionEvent）的资源并对它进行造型送入菜单项，然后得到动作指令字符串，再通过它去贯穿串联组，当然条件是对它进行声明。这些大多数同前面的一样，但请注意如果“Exit”被选中，通过进入封装类对象的句柄（MenuNew.this）并创建一个WINDOW_CLOSING事件，一个新的窗口事件就被创建了。新的事件被分配到封装类对象的dispatchEvent()方法，然后结束调用windowsClosing()内部帧的窗口接收器（这个接收器作为一个内部类被创建在main()里），似乎这是“正常”产生消息的方法。通过这种机制，我们可以在任何情况下迅速处理任何的信息，因此，它非常的强大。

FL接收器是很简单尽管它能处理特殊菜单的所有不同的特色。如果我们的逻辑十分的简单明了，这种方法对我们就很有用处，但通常，我们使用这种方法时需要与FooL，BarL和BazL一道使用，它们每个都附加到一个单独的菜单组件上，因此必然无需测试逻辑，并且使我们正确地辨识出谁调用了接收器。这种方法产生了大量的类，内部代码趋向于变得小巧和处理起来简单、安全。

1. 对话框

在这个例子里直接重写了早期的ToeTest.java程序。在这个新的版本里，任何事件都被安放进一个内部类中。虽然这完全消除了需要记录产生的任何类的麻烦，作为ToeTest.java的一个例子，它能使内部类的概念变得不那遥远。在这点，内嵌类被嵌套达四层之深！我们需要的这种设计决定了内部类的优点是否值得增加更加复杂的事物。另外，当我们创建一个非静态的内部类时，我们将捆绑非静态类到它周围的类上。有时，单独的类可以更容易地被复用。

//: ToeTestNew.java

// Demonstration of dialog boxes

// and creating your own components

import java.awt.;

import java.awt.event.;

public class ToeTestNew extends Frame {

TextField rows = new TextField("3");

TextField cols = new TextField("3");

public ToeTestNew() {

setTitle("Toe Test");

Panel p = new Panel();

p.setLayout(new GridLayout(2,2));

p.add(new Label("Rows", Label.CENTER));

p.add(rows);

p.add(new Label("Columns", Label.CENTER));

p.add(cols);

add(p, BorderLayout.NORTH);

Button b = new Button("go");

b.addActionListener(new BL());

add(b, BorderLayout.SOUTH);

}

static final int BLANK = 0;

static final int XX = 1;

static final int OO = 2;

class ToeDialog extends Dialog {

// w = number of cells wide

// h = number of cells high

int turn = XX; // Start with x's turn

public ToeDialog(int w, int h) {

super(ToeTestNew.this,

"The game itself", false);

setLayout(new GridLayout(w, h));

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

add(new ToeButton());

setSize(w 50, h * 50);

addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent e){

dispose();

}

});

}

class ToeButton extends Canvas {

int state = BLANK;

ToeButton() {

addMouseListener(new ML());

}

public void paint(Graphics g) {

int x1 = 0;

int y1 = 0;

int x2 = getSize().width - 1;

int y2 = getSize().height - 1;

g.drawRect(x1, y1, x2, y2);

x1 = x2/4;

y1 = y2/4;

int wide = x2/2;

int high = y2/2;

if(state == XX) {