站内搜索: 请输入搜索关键词

当前页面: 开发资料首页J2EE 专题事件监听器?将JavaBeans接通起来的方法

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

摘要: 事件监听器?将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&acute;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


Java, java, J2SE, j2se, J2EE, j2ee, J2ME, j2me, ejb, ejb3, JBOSS, jboss, spring, hibernate, jdo, struts, webwork, ajax, AJAX, mysql, MySQL, Oracle, Weblogic, Websphere, scjp, scjd, scwcd 摘 要 J
↑返回目录
前一篇: Java,Beans和关系数据库的镜像
后一篇: 定制你的Java--根据应用剪裁JavaBeans