事件監聽器?將JavaBeans接通起來的方法

2019-11-18 15:15:32

字體：大中小

來源：轉載

供稿：網友

　　摘要 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

上一篇：事件處理中UI的刷新問題(筆記體小品文)

下一篇：使用模仿對象進行單元測試