开发学院 WEB开发 Jsp 事件监听器?将JavaBeans接通起来的方法阅读

事件监听器?将JavaBeans接通起来的方法

　2008-01-05 08:40:32　来源：WEB开发网　　　

核心提示：摘要 javaBeans 通过事件( 封装着与所发生情况有关的数据的对象) 与其它软件组件进行通讯，本文将向你展示如何利用Java 的新的事件框架把Beans 接通起来，事件监听器?将JavaBeans接通起来

　　摘要 javaBeans 通过事件( 封装着与所发生情况有关的数据的对象) 与其它软件组件进行通讯。本文将向你展示如何利用Java 的新的事件框架把Beans 接通起来，以生成新的Beans 或构造完整的应用程序。在阐述这个问题的过程中，我们将会涉及到一些Java 语言的新特性。

通过适当配置，JavaBeans 能够去" 监听" 其它软件对象。而且正如你将要看到的一样，一个Java1。1 类( 包括任何一个JavaBeans) 一旦成为一个事件监听者，就不仅仅只能够监听其父类，而且能够监听所有产生事件的类。事件监听者的思想正是Java 类( 和其它JavaBeans) 如何处理事件的关键。

我先来介绍两个图标，它们将帮助我们识别一些关键问题。

JavaBeans 是一个重要概念

Cuppajoe 图标表示对于Java 语言来说新的或重要的思想

什么是事件
软件事件是一段说明某事已经发生的数据。用户移动鼠标，或从网上传来数据报，或传感器监测到某人非正常介入，所有这些发生的情况，都可以被看成是事件的实例，而有关这些情况的信息可以包括在事件之中。通常情况下，根据事件处理来开发软件系统是较为方便的: 在此情况下，程序设计变成一种对" 当此发生时，做彼" 式的叙述进行加工处理的过程。如果鼠标已被移动，则随之移动屏幕上的光标; 如果网上传来数据报，则读之; 如果发现有人侵入，则驱逐之。

通常而言，一个事件包括以下信息: 事件源( 产生事件或最初接收到事件的对象)，事件的发生时刻，和一些事件接收者可能用到的说明什么情况发生，如何去做的子类的具体信息。例如，在Windows 系统中，就应当有一个关于点击鼠标的事件子类。点击鼠标事件将包括点击鼠标时的时刻; 也可能包括当点击发生时，鼠标在屏幕上的位置，SHIFT 键和ALT 键的状态，是点击了鼠标左键还是右键等等诸如此类的信息。处理事件的编码，不可思议地被称为" 事件处理者"（event handler)。

那么，所有这些与JavaBeans 有何关系呢? 事件是Beans 相互通讯的主要方式。这点我们在下面将会看到。如果你正确地选择了事件和它们的连接，你就可能在你的应用系统中将Beans 相互接通，让每一个Beans 按照你的意愿去响应与其相关的事件。每一个Beans 将各负其责，对新来的事件进行适当地响应，并且当新的情况出现的时候，向相关的邻居Beans 发送新的事件。一旦你知道如何利用事件，你就能够写出通过事件和其他组件进行通讯的Beans。更进一步地讲，外部系统，例如集成开发环境(IDEs) 能够自动地检测你的Beans 所用的事件，并能让你以图解的方式来互连Beans。IDEs 同样也能向JavaBeans 发送事件和从JavaBeans 接收事件，本质上讲，可以从外部来控制JavaBeans。

为了了解事件怎样和Beans 一起工作，你就必须了解他们在Java 中是如何工作的。而事件工作的方式各不相同，JDK1。1 则是标准的。

JDK 1。0 的事件机制有何问题?
在JDK1。0 中，事件主要被用在抽象视窗工具包(AWT) 中，当在用户接口上出现某种情况时，它将通知相应的类。程序员应用继承机制，通过创建某个类的能够接收相应的事件类型的子类对象和重载父类的事件处理过程，来进行事件处理。

例如，在Java1.0 版中，能够获得某个行为事件(action event) 的唯一途径，就是把它从某个知道如何处理此行为事件的类中继承下来。

public class MyButton extends java.awt.Button
{
//重载action()方法以处理行为事件
public boolean action(Event evt, Object what)
{
//此处,做一些行为事件所做的事
}
}

这意味着，只有从java。awt。button 中继承下来的类才能够响应点击鼠标事件。这种组织结构与用户接口捆绑在一起，不够灵活方便。它不便于构造新的事件类型。而且即便你能够构造新的事件，你也很难改变那些将被类响应的事件，因为有关的信息都被僵硬地固化在AWT 的" 族系树"( 继承图) 中。

新的JDK1。1 拥有一个更为普适的事件框架，它能够让产生事件的类和其它不产生事件的类互相通讯。新的模式放弃了定义客户子类必须重载的事件处理函数( 方法) 的工作方式，转而采用定义接口的方式。如果一个类需要接收某一特定的消息类型，则这个类可以使用所定义的接口。( 你可能会明白，这意味着通过" 授权"(delegation)，而不是通过" 继承"(inheritance) 来处理事件)。我们将还以JDK1。0 button 例子来说明JDK1。1 的模式。

我在此想要做的事是，构造一个新的类，使它能够在按钮被按下时，去做某件事情。在JDK1。0 版中，为了处理与按钮(Button) 行为相关的事件，我必须继承java。awt。Button，这样，一旦某个按钮被按下时，该按钮将会让我的新类知道。

//...在程序的另一个地方,我们定义了"监听"按钮行为的对象
ActionListener myActionListener = new ActionListener();
//...

//按钮行为事件
public class MyButton extends java.awt.Button
{
//重载action()以通知我的新类
public boolean action(Event evt, Object object)
{
myActionListener.action(evt, object);
}
}

现在，每当MyButton 被按下时，myActionListener 对象都会收到一个事件。myActionListener 并非一定要是java。awt。Component 的一个子类，但它的确要包括一个action() 方法。我们把这个新类称为ActionListener，是因为这个新类一直将要" 监听" 它所依附的Botton 的行为事件。在此，仍有一些问题存在:

当按下此按钮时，将要通知的对象是固定在程序中的，这就是说，我不能在程序运行时刻(runtime)" 重新接通"Button 和myActionListener 的关系。

仅有一个对象可被通知到; 如果其它几个对象都与点击Button 有关系，这该如何解决?

我们仍然没有解决通过" 继承" 来接收按钮行为事件的难题-- 这就是说，myActionListener 仍必须从某个" 了解" 按钮及其行为事件的类中继承下来。
对第一个问题，有一个可供选择的办法是在MyBotton 类中增加setListener(ActionListener newListener) 及myNewClass getListener() 两个方法，和一种能更换被通知的对象的途径。然而非常不幸，我们仍然不能仅仅局限于为每一个按钮关连一个对象，因而下面你将看到，我们将生成一系列的监听器(listeners)。

//按钮行为事件( button action event)
public class MyButton extends java.awt.Button
{
PRivate Vector listeningObjects = new Vector();

//重载action()以通知我的新类
public boolean action(Event evt, Object object)
{
for (int i = 0; i

好了，现可以看到，任何一个ActionListener 的实例都可以通过调用addActionListener(this)" 监听" 任何一个Mybutton 实例上的事件，并且通过调用removeActionListener(this) 结束" 监听"。这一进步的确不错，但是有关" 继承" 的问题仍然困绕着我们: 只有Button 和ActionListener 对象( 及其派生类对象) 才能接收到Button 行为事件。对此，Java 有着新的解决路线: 接口。

接口和事件监听器
在Java 术语表(http://Java。sun。com/docs/glossary。Html) 中将接口定义如下:

接口(interface): 在Java 中，是一组特定的方法，这些方法可以在多个不同的类中实现，而不必考虑这些类在类系结构中的等级关系。

为什么它会如此有用?
接口定度了一 “角色”，通过实现这一接口中的一系列操作，每一个类都可以扮演接口的角色。

接口的定义和类的定义看起十分相似:

// 仍在JDK1.0 内
public interface ActionListener
{
void action(Event evt, Object object);
}

任何想成为ActionListener 的类只要简单地定义一个行为函数，并且通过应用"implements" 关键词，声明它实现ActionListener 接口:

public class SomeRandomClass extends SomeOtherClass implements ActionListener
{
//实现ActionListener方法
void action(Event evt, Object object)
{
//做所要做的事
}

SomeRandomClass()
{
super();
// Blah blah blah...
}
// ...继续实现SomeRandomClass方法
}

这很直接，拥有接口，你将不会再被禁锢于森严的单一继承阶层体系中。

按照面向对象的语法，继承常常被称为一种ISA( 即IS A) 关系: 人类继承于哺乳动物，因为人是一种(IS A) 哺乳动物。对象通过参照索引或指针建立起来的联系，在有些情况下被称为HASA(has a，有一个) 关系: 如一辆汽车HASA 机轴。

接口结构给面向对象的思想注入了ACTS_AS_A(act as a，充当一个) 的概念。在上面的例子中，任何一个想充当(ACTASA)ActionListener 的类只需实现接口即可。

在接口中的所有方法都只能抽象地定义，也就是说，在接口中不应有( 也不该有) 实际的方法代码。因此，如果你的类扩充了一个接口，你就必须为每一个方法提供某个具体的实现。

JDK1 。1AWT 为你预先定义了处理事件的接口，并且AWT 用户接口元件提供了上面所说的addEventtypeListener 和removeEventTypeListener 。例如，在JDK1 。1 中，在java 。awt 。Button 就有以下两个方法:

void addActionListener(ActionListener listener)
void removeActionListener(ActionListener listener)

这就意味任何一个ActionListener 能够将自已加入到监听Action 事件的对象列表中。一个类通过实现(implement)ActionListener 接口取得ActionListener 的资格。

public interface ActionListener extends EventListener
{
public void actionPerformed(ActionEvent e)
}

所有想接收事件的类，至此不必从ActionListener 中继承了 ? ? 它们仅仅只需实现ActionListener，并对某些对象充当ActionListener 的替代角色，即能够去接收事件。

actionPerformed 方法的参数，ActionEvent，是一个源于java 。util 。EventObject 的类，它提供了几个有用的函数，来帮助事件监听器认清当事件发生时，是谁在发送事件，SHIFT 和ALT 键处于什么状态等等之类的情况。读者可以从联机文件中查看这些事件的全部功能( 参见下面的" 资源" 一段) 。

同时也应当注意，接口扩充EventListener，而EventListener 本身也是一个没有方法的接口，需要事件监听器去扩充空的java 。util 。EventListener 接口，该接口可使程序（特别是IDEs) 用一抽象的方法( 例如保存一个EventListeners 的清单) 去操纵其各种子类的EventListeners 。

所有这些与Beans 有何关系?
JavaBeans主要利用事件监听器接口进行通讯

事件监听器为对象提供了一种普适的不经过继承关系而进行通讯的方法。正因为如此，他们对于组件技术来说，是一种非常好的通讯机制，从某种角度来讲，它们即是JavaBeans 。虽然上面看到的事件监听器全都出现在AWT 中，但他们的应用不仅仅限于用户接口。他们可以被应用于各式各样的事件: 属性的变更，传感器的阅读，时钟事件，文件系统行为，对象命名等。

现在开始 “Beany”部分

# 你能够为它们定义你自己的事件类型和事件监听器。

# 如果你的新事件类型被称为Eventtype，那么通过实现下面两个方法，你的Beans 就能成为你的新事件类型的源。

o addEventtypeListener(EventObject e)
o removeEventtypeListener(EventObject e)

# 那么通过实现接口EventListener，其它Beans 能够成为事件的目标。

# 最后，你可以通过调用sourceBean 。addEventtypeListener(targetBean)" 接通" 事件的源和事件目标。

创建和利用你自已的EventObject 类型
让我们看一个创建EventObject 类型的例子。这个例子是在上个月的一个例子，BarChartBean 的基础上进行" 脑外科式"(brain surgery) 的改造而成的。我先在BarChartBean 中增加代码，以使得在Bar 区域内，用户每次点击或拖动鼠标时，都重先设置percent 属性。这为我们提供了一个通过鼠标来改变Percent 属性的方法。

BarChartBean 通过预先定义的PropertyChangeListener 接口( 在java 。beans 包中定义的，通用的事件监听器接口)，来通知其它对象它的percent 属性变化情况。现在，我们通过定义一个新的事件类型，PercentEvent，为外部Beans 增加另一个方法，以使这些Beans 能够被通知到每一次percent 的变化。

import java.util.*;

//
//该类封装每一次Percent属性的变化,并将变化传递给"PercentListener".
//

public class PercentEvent extends java.util.EventObject
{
protected int iOld_, iNew_;

public PercentEvent(Object source, int iOld, int iNew)
{
super(source);
iOld_ = iOld;
iNew_ = iNew;
}

public int getOldPercent() { return iOld_; }

public int getPercent() { return iNew_; }

public int getChangedBy() { return iNew_ - iOld_; }
}

你是否还记得，在前面我们曾提到过在事件中封装类规范(class-specific) 数据? 妤了，在此，新的和旧的百分比值都规范于PercentEvent 事件类。

现在，让我们为这一新的事件类型定义一个监听器接口。

import java.util.*;

//每一个想监听"percent"变化情况的类都
//应该实现这个接口

public interface PercentListener extends EventListener
{
public void percentChanged(EventObject e);
}

接下来，我们要把BarChartBean 变成为一个PercentEvent 的源。为达此目的，我们将在BarChartBean 中实现addPercentListener() 和removePercentListener()，并且无论何时，当percent 属性改变时，都能够去修改所有的监听器。( 在此，我们只需看源代码中相关的部分)

//
// BarChart Bean现在接收输入
//
public class BarChartBean extends Canvas
implements Serializable, PropertyChangeListener
{
// ...
// List of percent listeners.
private Vector percentListeners_;

// ... a whole lotta methods...

// Set/Get methods for percent
public void setPercent(int ipercent)
{
// Set new percent, and only if necessary repaint()
// This is the only place that iPercent´s range is controlled
if (iPercent <= 100 && iPercent>= 0)
{
// Save old value, set new value FIRST
int prevPercent = iPercent_;
iPercent_ = iPercent;

// Notify property listeners of change to "percent" property
pcs_.firePropertyChange("percent",
new Integer(prevPercent),
new Integer(iPercent_));

// Notify all listeners for "percent" change
notifyPercentChanged(prevPercent, iPercent);

// Repaint only if necessary.
if (prevPercent != iPercent_)
{
repaint();
}
}
}

// ...

//
// These methods are for handling "PercentListeners"
//

// Add a new percent listener
public synchronized void addPercentListener(PercentListener listener)
{
percentListeners_.addElement(listener);
}

// Remove a percent listener
public synchronized void removePercentListener(PercentListener listener)
{
percentListeners_.removeElement(listener);
}

// Notify all listeners that "percent" changed
protected void notifyPercentChanged(int oldPct, int newPct)
{
Vector thisList = new Vector();
PercentEvent thisEvent = new PercentEvent(this, oldPct, newPct);

// Make a copy of the list so potential changes to it by
// other threads won´t affect traversal.
synchronized (this)
{
thisList = (Vector)percentListeners_.clone();
}

// Send a "PercentEvent" to every listener.
for (int elem = 0; elem

矢量percentListeners_ 是一列当percent 属性改变时，需要被通知的PercentListeners( 实现了PercentListener 接口的对象) 清单。在源程序的更下方，以前的setPercent() 方法调用firePropertyChange()，而现在，它还调用notifyPercentChanged() 以通知在percentListeners_ 清单中的所有对象。( 在此，实际上，我们提供了两种通知percent 变化的方法:( 以前的) 作为一个PropertyChange，和现在的作为一个PercentEvent。)

addPercentListener() 和removePercentListener() 方法仅仅向监听器清单中追加或从清单中删除对象。追加和删除同步进行，因为多线索将尽可能向清单中追加或从清单中删除监听器。如果在处理这一列清单的过程中，发生一个上下文转换(a context switch)，那么可怕的事情将会发生。( 这个清单可能被毁坏。如果你足够幸运，它可能会导致错误难以查找; 如果你不幸运的话，它将会使应用程序行为不可预测，更有胜之，毁坏数据。)

实质上的工作是在notifyPercentChanged() 中进行的。根据输入的数据，它将创建一个新的PercentEvent 事件，接着percentListeners_ 清单将被克隆，也就是说，它将被彻底复制到一个新的矢量中。synchronized 关键词暗示我们为什么这样做的理由: 当我们部分遍历这一清单时，另一条线索正要删除某一监听器，那会出现什么情况呢?( 参见前一段中的" 可怕事件"。)notifyPercentChanged() 中的循环只简单地根据我们创建的清单，将PercentEvent 事件传递给所有的监听器。

当然，如果没有事件目标，一个事件源对于我们也没有任何价值。下面，我们将创建一个Bean，它其实是一条标签，能够在接收到一个PercentEvent 事件后，随之改变。

import java.util.*;
import java.io.*;
import java.awt.*;
import PercentListener;
import PercentEvent;

public class PercentLabel
extends Label
implements Serializable, PercentListener
{
public PercentLabel() { }

public void percentChanged(EventObject event)
{
if (event instanceof PercentEvent)
{
PercentEvent pe = (PercentEvent) event;
setText(Integer.toString(pe.getPercent()));
}
}
}

上面例子非常简单。现在，我们所要做的就是将二者连接起来:

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

public class Example
extends Panel
implements Serializable
{
private PercentLabel pl_ = new PercentLabel();
private BarChartBean bcb_ = new BarChartBean();

public Example()
{
bcb_.addPercentListener(pl_);
setLayout(new BorderLayout());
add("North", pl_);
add("South", bcb_);
}
}

下面就是所得到的BEAN:

PercentChange事件工作正常

你可以下载JAR 文件并在BeanBox 中自己试着这样做。

现在的问题是，既然PropertyChange 接口已经存在，那么，为什么每个人都还想去做额外的工作，来创建他们自已的事件类型呢? 一个可能的原因是，同PropertyChange 所允许传递的信息相比，在事件中，你能够传递更多的信息。你可以在一个事件中，封装你所想要的任何东西。实际上，上一个月我们所见到的PropertyChange 机制其实是根据我们刚才所见的事件监听器实现的。

事件也比PropertyChange 更加通用。新的AWT 定义了诸如鼠标移动、敲击键盘、调整组件大小等等的事件类型。你可能想在你的应用程序中，为这些新的事件，分别定义一个新的事件处理类，并且使得他们不全都去本能地模仿PropertyChange。例如，在一个ModemControl Bean 中，你可以创建一个新的ModemEvent 类，并创建一个适当的监听器接口，使其它Beans 能够监听到诸如ModemConnectEvent，ModemDisconnectEvent 等等之类的事件。这种做法将比有一个被称为"ModemState"( 或其它什么的) 属性的做法更为合理。后者的做法中，"ModemState" 属性在有些情况下只能读出(read only)，而其他的情况下既可读又可写，其实并不是真正意义上的" 属性"。

IDEs 能够利用新的Java 映像机制，这种机制可使Java 程序分析类文件，以分析Beans。IDEs 能够寻找实现EventListener 的类( 以找出事件的目标)，并能够寻找名字象addSomethingListener() 的方法( 以找出事件的源)。( 请记住上面关于空的EventListener 接口对IDEs 有用的评论- 这就是有用的原因。) 你也可以在你的Beans 中增加方法以明确地告诉IDEs( 或其它任何提问者) 你的Bean 产生或处理什么事件。

我们刚刚手工编写了一个名为Example 的类，它能够利用某个监听器接口使一个Bean 和另一个Bean" 接通"。在此，我们将把它做得更好，利用可视化编程环境实现同样的功能。下面的几步将在BeanBox 上实现。

在你的jars 目录中，打开带有ColorBar。Jar 的BeanBox，以使得example Bean 能被装载。

向BeanBox 中增加一个BarChartBean。

往BeanBox 中加入一个PercentLabel( 最好将其变为白色，以便容易看到)。

选择在BeanBox 中的BarchartBean。

选择菜单项Edit->Events->percent->percentChanged。现在你能够看到:BeanBox 自动地识别新的事件类型并将其加入到事件列表清单中，这一清单你可从BarChartBean 中得到。真Cool!

你需要一条红色的橡皮带式生成线。移动鼠标到PercentLabel 上，并点击它。

一个对话框将出现，问你当一个percentChanged 事件到达PercentLabel 时，你希望选择调用哪一个方法。你选择percentChanged。
BeanBox 创建一个"adaptor" 类，它即是一个PercentListener。

接下来，BeanBox 编译它所写的adaptor 类，创建一个实例，并且利用BarChartBean。addPercentListener() 调用它。一旦BarChartBean 产生了percent 事件，它将这些事件传递给adaptor( 因为adaptor 是一直在" 监听")，adaptor 接着将事件传递给PercentListener。percentChanged()。

实际上, 下面是BeanBox 产生的"adaptor" 类的代码:

// 自动生成的事件连接文件.

package tmp.sun.beanbox;
import PercentLabel;
import PercentListener;

public class ___Hookup_1452f9e502 implements PercentListener, java.io.Serializable
{

public void setTarget(PercentLabel t)
{
target = t;
}

public void percentChanged(java.util.EventObject arg0)
{
target.percentChanged(arg0);
}

private PercentLabel target;
}

现在，只须象以前一样应用BarChartBean，PercentListener 就会自动地跟踪percent 事件。这就是可视化的应用程序开发。
如果你的浏览器支持动态GIF 文件，请访问该地址（http://www。javaworld。com/javaworld/jw-10-1997/images/percentdemo.gif) 以看到这一过程的动态演示。

Bean-a-palooza: 为同一类型的事件分组
在你写监听器接口的时候，应当注意到，通常情况下，仅创建一个监听器接口，使其包括一个若干相关事件共用的Eventtypeperformed() 方法，比为每一个事件都创建一个监听器接口的做法更加省事而且简便。

关于这种思想的一个好例子是JKD1。1 AWT 中鼠标事件的处理方式。( 实际上，其中有两种这样的接口，根据处理效率的不同要求，将鼠标事件进行分组)。

为了捕捉新的AWT 中的鼠标事件，一个类必须实现的下面两个接口中的一个或者全部:java。awt。event。MouseListener 或java.awt.event.MouseMotionListener. 这两个接口分别包括以下方法:

public interface MouseListener extends EventListener
{
public void mouseClicked(MouseEvent e);
public void mouseEntered(MouseEvent e);
public void mouseExited(MouseEvent e);
public void mousePressed(MouseEvent e);
public void mouseReleased(MouseEvent e);
};

public interface MouseMotionListener extends EventListener
{
public void mouseDragged(MouseEvent e);
public void mouseMoved(MouseEvent e);
}

就目前而言,AWT 的设计者原本能够非常简便地定义大量的接口和相关的事件类型:

public interface MouseClickListener extends EventListener
{
public void mouseClicked(MouseClickEvent e);
}

public interface MouseEnterListener extends EventListener
{
public void mouseEntered(MouseEnterEvent e);
}

// 等等

但是，AWT 的设计者其实是将多个方法进行分组，分别归类到上面所说的两个接口中。一个需要接收鼠标事件的类只须声明它实现MouseListener，并接着实现所有的诸如void mouseClicked(MouseEvent e)， void mouseEntered(MouseEvent e) 等等之类的方法，即可当事件发生时，能够去做任何需要做的事。如果你对mouseExits 事件不感兴趣，你所要做的仅仅就是使这一方法不做任何事情。( 实现一个接口时，Java 需要其中所有的方法都被定义。如果接口中的所有方法没有被完全被定义，那么你的类将不能通过编译。当然也有办法绕过这一情况-- 可参见下面的"Do Nothing 类"。)

为什么Java 设计者不将所有的鼠标事件处理方法都归入到同一个接口中，而是将这些方法分成两类分别归到MouseListener 和MouseMotionListener 两个接口中呢? 这涉及到一个性能问题: 鼠标移动事件出现频率高而且速度快，远远快于点击鼠标按钮的速度。如果实际运行中，没有一个类来监听鼠标的移动，那么，AWT( 内部地) 就会丢弃它所接收到的任何此类事件，以节省时间，而不将时间浪费在调用一个其实并不做任何事情的方法之上。

在前面，我已提到了将要进一步讨论的一个办法，它希望绕过Java 恼人的而且顽固坚持的行径: 一个接口中的所有方法都必须被定义，即使这些方法不做任何事情。下面我们将写一个类，它将跟踪并保存下鼠标被点击的次数。这个类的相关部分大致如下:

// count right mouse clicks
public class ClickCounter extends Panel implements MouseListener
{
private int iClicks_ = 0;

// Listen for events on self
ClickCounter() { addMouseListener(this); }

public void mouseClicked(MouseEvent e) { iClicks_++; repaint();}
public void mouseEntered(MouseEvent e) { }
public void mouseExited(MouseEvent e) { }
public void mousePressed(MouseEvent e) { }
public void mouseReleased(MouseEvent e) { }
public void paint() { // paint the # of clicks on the panel }
}

从上可以注意到，必须定义许多无用的空函数的确是件恼人的事。所幸的是，AWT 的设计者为你解决了这一难题: 他们创造了不做任何事情的类。

不做任何事情的类(Do-nothing classes)
java。awt。event。MouseAdapter 类所要做的事就是不做任何事情。它实现MouseListener 类，并且它的方法丢弃所接收到事件。其方法不做任何事件的类能够有什么用途呢? 对于类自身而言，几乎一无所用 ? ? 然而，你可以创建一个MouseAdapter 的子类，并在子类中仅仅实现那些你感兴趣的方法。上面所说的ClickCounter 例子现在可以这样实现:

public class ClickCounter extends MouseAdapter
{
private int iClicks_ = 0;

// Listen for events on self
ClickCounter() { addMouseListener(this); }

public void mouseClicked(MouseEvent e) { iClicks_++; repaint();}
public void paint() { // paint the # of clicks on the panel }
}

与前面的将类定义为实现MouseListener 的做法不同，在这里，类的定义通过扩展MouseAdapter 完成，并且将MouseAdapter 类中不做任何事的函数斩草除根( 因此你就不必写出那些不做任何事的方法)。你要写的所有的函数就是mouseClicked()，它也就是你所感兴趣的所有事情。这难道不够方便吗?

你将会发现，在AWT 中的绝大多数的事件监听器接口群组都包括三个相关的定义:

EventtypeEvent: 所发生的事件

EventtypeListener: 事件监听接口

EventtypeAdapter: 不做任何事件的adaptor 类，你可因此而不必。。。
所有这些对于Beans 的重要意义是:

当为你Beans创建事件监听接口时：

在事件监听器接口中，为相关的事件类型分组

如果在接口中有多个方法，提供一个adapter 类以使你的接口更容易应用。
内嵌类
现在，想象你有20 个用户接口widget 类型，并且当某一MouseEvent 事件发生时，这些接口类型各自做不同的事情。你的名字空间将会被诸如:DrawPaneMouseEvent，MousePositionMouseEvent 等等的各种事件处理类弄得混杂不堪。而且这些类都仅仅能够被用于那些" 拥有" 它们的类。Java 1。1 中，有一种名为内嵌类的新机制允许你来控制类的定义范围。

在Java 中，内嵌类是在另一个类中定义的类。它的" 活动范围"( 或" 可见范围") 仅仅限于类被定义时所在的块。

内嵌类是Java1。1 的新特性，它对于定义某些adaptor 类是十分有用的，这些类" 通晓" 它们所操纵的对象的实现详情。ClickCounter 提供了这样的一个( 非常简单的) 例子:

public class ClickCounter extends Panel
{
private int iClicks_ = 0;

class MouseHandler extends MouseAdapter
{
public void mouseClicked(MouseEvent e)
{ iClicks_++; repaint();}
}

// Listen for events on self
ClickCounter() { addMouseListener(new MouseHandler()); }

public void paint() { // paint the # of clicks on the panel }
};
// 下面的语句不合法, 将不会通过编译!
MouseHandler m = new MouseHandler();

上面的程序对被称为MouseHandler 的内嵌类的点击鼠标事件进行推迟处理。这个类" 知道" 包括它的类所拥有的变量"iClicks"。如果你企图在一个" 顶层" 类( 也就是说，任何不是内嵌类的类) 中这样做，那么，你就不可能得到ClickCounter 中(iClicks 的) 具体的实现情况。你将不得不增加一些方法来控制点击的计数，这样一来，你也破坏了封装机制。( 词语" 顶层类"(top-level class) 是一个retronym，就是说，它是对旧事物的一个新名字。)

在此例中，我故意包括了一个错误: 在ClickCounter 类的范围之外，定义了一个MouseHandler 对象。程序在编译时将会出错，因为MouseHandler 并不是在ClickCounter 类之外定义的。如果某一顶层类碰巧被命名为MouseHandler，那么代码将会正常被编译，但MouseHandler m 将不会与ClickCounter 的内嵌类同型。应该看到: 用这种办法分离名字空间是内嵌类的一个目的。

内嵌类有一个值得引起注意的地方是: 虽然它们的范围不同于顶层类的范围，但每一个你定义的内嵌类都被编译到它自己的类文件中。在Win32 系统中， ClickCounter 的内嵌类文件名将会是ClickCounter$MouseHandler。class。 ( 核查你的文件或做一点小试验，来看一看在你的系统上它是怎么工作的。) 这里值得注意的是，即使这些内嵌类不是Beans，你的Beans 所定义的每一个内嵌类将会用到它们的( 内嵌) 类文件，否则，Beans 将不会转动。所以，一定要在你的JAR 文件中包括你所定义的内嵌类所用到的类文件。

如果你还想参看另一个利用内嵌类事件adaptor 处理鼠标事件的例子，你可以查阅BarChartBean 的源码。参见下面的Resources，你可以获得此源码及更多的有关内嵌类的信息( 其中有些东西的确不可思意)。

张智雄编译自：http://www.javaworld.com/javaworld/jw-05-1997/jw-05-step.html