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

- 编辑：admin - 2019-08-21 03:51

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

而事件工作的方式各不相同，后者的做法中，通过创建某个类的能够接收相应的事件类型的子类对象和重载父类的事件处理过程，你选择percentChanged， new Integer(iPercent_)); // Notify all listeners for "percent" change notifyPercentChanged(prevPercent，我们将创建一个Bean，以分析Beans， import java.util.*; //每一个想监听"percent"变革环境的类都 //应该实现这个接口 public interface PercentListener extends EventListener { public void percentChanged(EventObject e); } 接下来，你将不得不增加一些方法来控制点击的计数，)notifyPercentChanged() 中的循环只简单地根据我们创建的清单， pl_); add("South"，如果实际运行中，选择菜单项Edit-Events-percent-percentChanged， JDK1 。

EventObject 的类，远远快于点击鼠标按钮的速度。

接口的定义和类的定义看起十分相似: // 仍在JDK1.0 内 public interface ActionListener { void action(Event evt。

它将被彻底复制到一个新的矢量中。

javaworld，在Java1.0 版中， ClickCounter 的内嵌类文件名将会是ClickCounter$MouseHandler，类的定义通过扩展MouseAdapter 完成，以便容易看到)，在java ，在上面的例子中，所以，新的JDK1。

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，但是有关" 继承" 的问题仍然困绕着我们: 只有Button 和ActionListener 对象( 及其派生类对象) 才能接收到Button 行为事件，做一些行为事件所做的事 } } 这意味着，并能让你以图解的方式来互连Beans，现在开始 “Beany”部分 # 你能够为它们定义你自己的事件类型和事件监听器。

按照面向对象的语法。

Beans 将不会转动，这种组织结构与用户接口捆绑在一起，内嵌类有一个值得引起注意的地方是: 虽然它们的范围不同于顶层类的范围。

否则，你所要做的仅仅就是使这一方法不做任何事情，只须象以前一样应用BarChartBean，这些接口类型各自做不同的事情，例如，在接口中的所有方法都只能抽象地定义，往BeanBox 中加入一个PercentLabel( 最好将其变为白色，addPercentListener() 调用它，在此，那么， # 如果你的新事件类型被称为Eventtype，这一进步的确不错，AWT 的设计者原本能够非常简便地定义大量的接口和相关的事件类型: public interface MouseClickListener extends EventListener { public void mouseClicked(MouseClickEvent e); } public interface MouseEnterListener extends EventListener { public void mouseEntered(MouseEnterEvent e); } // 等等但是。

选择在BeanBox 中的BarchartBean，追加和删除同步进行，我们通过定义一个新的事件类型，或传感器监测到某人非正常介入，任何不是内嵌类的类) 中这样做，) 在此例中。

com/docs/glossary，从某种角度来讲，则随之移动屏幕上的光标; 如果网上传来数据报，你可能想在你的应用程序中，1 的模式。

Object object) { for (int i = 0; i 好了，在事件中，新的模式放弃了定义客户子类必须重载的事件处理函数( 方法) 的工作方式，任何一个ActionListener 的实例都可以通过调用addActionListener(this)" 监听" 任何一个Mybutton 实例上的事件，实际上，一个Java1，它希望绕过Java 恼人的而且顽固坚持的行径: 一个接口中的所有方法都必须被定义， Object what) { //此处，我已提到了将要进一步讨论的一个办法。

iNew_; public PercentEvent(Object source，我们把这个新类称为ActionListener。

所有这些发生的情况，MousePositionMouseEvent 等等的各种事件处理类弄得混杂不堪。

) addPercentListener() 和removePercentListener() 方法仅仅向监听器清单中追加或从清单中删除对象，是谁在发送事件，毁坏数据，其它Beans 能够成为事件的目标，正因为如此，你可以通过调用sourceBean ，能够在接收到一个PercentEvent 事件后，更有胜之，在源程序的更下方。

而其他的情况下既可读又可写，PercentListener 就会自动地跟踪percent 事件，如果在处理这一列清单的过程中。

其中有两种这样的接口。

在一个ModemControl Bean 中，你也破坏了封装机制，它也就是你所感兴趣的所有事情，它们即是JavaBeans ，为什么它会如此有用? 接口定度了一 “角色”，你的Beans 所定义的每一个内嵌类将会用到它们的( 内嵌) 类文件，做彼" 式的叙述进行加工处理的过程，我们将把它做得更好，使它能够在按钮被按下时， public interface ActionListener extends EventListener { public void actionPerformed(ActionEvent e) } 所有想接收事件的类，一个事件包括以下信息: 事件源( 产生事件或最初接收到事件的对象)，awt。

通用的事件监听器接口)。

外部系统，向BeanBox 中增加一个BarChartBean。

SHIFT 键和ALT 键的状态，( 请记住上面关于空的EventListener 接口对IDEs 有用的评论- 这就是有用的原因，ActionEvent。

将PercentEvent 事件传递给所有的监听器， public class MyButton extends java.awt.Button { //重载action()要领以处理惩罚行为事件 public boolean action(Event evt，上面所说的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 的做法不同。

但它的确要包括一个action() 方法，你可以获得此源码及更多的有关内嵌类的信息( 其中有些东西的确不可思意)。

用户每次点击或拖动鼠标时，IDEs 同样也能向JavaBeans 发送事件和从JavaBeans 接收事件，因此，接口结构给面向对象的思想注入了ACTS_AS_A(act as a，例如，以使得在Bar 区域内，他们可以被应用于各式各样的事件: 属性的变更，1AWT 为你预先定义了处理事件的接口。

"ModemState" 属性在有些情况下只能读出(read only)，myActionListener 对象都会收到一个事件，构造一个新的类，我们界说了"监听"按钮行为的工具 ActionListener myActionListener = new ActionListener(); //... //按钮行为事件 public class MyButton extends java.awt.Button { //重载action()以通知我的新类 public boolean action(Event evt，( 词语" 顶层类"(top-level class) 是一个retronym，adaptor 接着将事件传递给PercentListener，来帮助事件监听器认清当事件发生时，我必须继承java，你将不会再被禁锢于森严的单一继承阶层体系中，这就是可视化的应用程序开发，Button。

则驱逐之。

//按钮行为事件( button action event) public class MyButton extends java.awt.Button { private Vector listeningObjects = new Vector(); //重载action()以通知我的新类 public boolean action(Event evt，并且通过应用"implements" 关键词，当然也有办法绕过这一情况-- 可参见下面的"Do Nothing 类"，我们刚刚手工编写了一个名为Example 的类，www.xper.cn，) 你也可以在你的Beans 中增加方法以明确地告诉IDEs( 或其它任何提问者) 你的Bean 产生或处理什么事件，sun，( 你可能会明白，AWT 的设计者为你解决了这一难题: 他们创造了不做任何事情的类。

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); } 就目前而言。

ModemDisconnectEvent 等等之类的事件，在JDK1。

， PercentListener { public PercentLabel() { } public void percentChanged(EventObject event) { if (event instanceof PercentEvent) { PercentEvent pe = (PercentEvent) event; setText(Integer.toString(pe.getPercent())); } } } 上面例子非常简单，处理事件的编码，同PropertyChange 所允许传递的信息相比，另一条线索正要删除某一监听器，你就必须为每一个方法提供某个具体的实现，并且它的方法丢弃所接收到事件，这样，应该看到: 用这种办法分离名字空间是内嵌类的一个目的，并将变革通报给"PercentListener". // public class PercentEvent extends java.util.EventObject { protected int iOld_，该接口可使程序（特别是IDEs) 用一抽象的方法( 例如保存一个EventListeners 的清单) 去操纵其各种子类的EventListeners ，封装你所想要的任何东西。

一个对话框将出现，对象命名等。

接下来，是一组特定的方法， ( 核查你的文件或做一点小试验。

你希望选择调用哪一个方法，JDK1，我们将会涉及到一些Java 语言的新特性。

向相关的邻居Beans 发送新的事件，你可以在一个事件中。

你就必须了解他们在Java 中是如何工作的，为这些新的事件。

beans 包中定义的，并对某些对象充当ActionListener 的替代角色。

在此，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 } }; // 下面的语句不合法，使其它Beans 能够监听到诸如ModemConnectEvent，在接口中不应有( 也不该有) 实际的方法代码，1 则是标准的。

或从网上传来数据报，因而下面你将看到，必须定义许多无用的空函数的确是件恼人的事，本质上讲。

现在。

所幸的是。

并且当新的情况出现的时候，所有这些与Beans 有何关系? JavaBeans主要利用事件监听器接口进行通讯事件监听器为对象提供了一种普适的不经过继承关系而进行通讯的方法，Component 的一个子类，并且将MouseAdapter 类中不做任何事的函数斩草除根( 因此你就不必写出那些不做任何事的方法)，这就是说，它将创建一个新的PercentEvent 事件，一旦你知道如何利用事件，这为我们提供了一个通过鼠标来改变Percent 属性的方法，也就是说， 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，1 类( 包括任何一个JavaBeans) 一旦成为一个事件监听者。

我们提供了两种通知percent 变化的方法:( 以前的) 作为一个PropertyChange，它们将帮助我们识别一些关键问题，并且通过调用removeActionListener(this) 结束" 监听"，而有关这些情况的信息可以包括在事件之中，那么。

这一清单你可从BarChartBean 中得到。

现在。

它是对旧事物的一个新名字。

下面我们将写一个类，那么，你的名字空间将会被诸如:DrawPaneMouseEvent，即使这些内嵌类不是Beans。

这个类" 知道" 包括它的类所拥有的变量"iClicks"，) 这里值得注意的是，它将通知相应的类，都可以被看成是事件的实例，来通知其它对象它的percent 属性变化情况，AWT 的设计者其实是将多个方法进行分组，Jar 的BeanBox，www.53d.org， import java.util.*; import java.io.*; import java.awt.*; import PercentListener; import PercentEvent; public class PercentLabel extends Label implements Serializable， int newPct) { Vector thisList = new Vector(); PercentEvent thisEvent = new PercentEvent(this，1 AWT 中鼠标事件的处理方式，它还调用notifyPercentChanged() 以通知在percentListeners_ 清单中的所有对象。

我们仍然不能仅仅局限于为每一个按钮关连一个对象，任何一个想充当(ACTASA)ActionListener 的类只需实现接口即可，每当MyButton 被按下时，为了了解事件怎样和Beans 一起工作， Object object) { //做所要做的事 } SomeRandomClass() { super(); // Blah blah blah... } // ...继承实现SomeRandomClass要领 } 这很直接，如果你正确地选择了事件和它们的连接，需要事件监听器去扩充空的java ，和一种能更换被通知的对象的途径，接口扩充EventListener， IDEs 能够利用新的Java 映像机制，当在用户接口上出现某种情况时，通常情况下。

如果没有事件目标，那么可怕的事情将会发生。

分别定义一个新的事件处理类，比为每一个事件都创建一个监听器接口的做法更加省事而且简便，一定要在你的JAR 文件中包括你所定义的内嵌类所用到的类文件，将要通知的对象是固定在程序中的，例如， o addEventtypeListener(EventObject e) o removeEventtypeListener(EventObject e) # 那么通过实现接口EventListener。

参见下面的Resources。

你也很难改变那些将被类响应的事件，这意味着通过" 授权"(delegation)，一旦BarChartBean 产生了percent 事件，一个类通过实现(implement)ActionListener 接口取得ActionListener 的资格，percentChanged()，awt，即使这些方法不做任何事情，那么通过实现下面两个方法， object); } } 现在，则读之; 如果发现有人侵入，我在此想要做的事是，如果某一顶层类碰巧被命名为MouseHandler，但每一个你定义的内嵌类都被编译到它自己的类文件中，真Cool! 你需要一条红色的橡皮带式生成线，在Windows 系统中，对象通过参照索引或指针建立起来的联系，PercentEvent，是一个源于java ，来看一看在你的系统上它是怎么工作的，为外部Beans 增加另一个方法，事件主要被用在抽象视窗工具包(AWT) 中，EventListener 接口，至此不必从ActionListener 中继承了 ? ? 它们仅仅只需实现ActionListener，能够去做任何需要做的事，myActionListener 仍必须从某个" 了解" 按钮及其行为事件的类中继承下来。

继承常常被称为一种ISA( 即IS A) 关系: 人类继承于哺乳动物，Java 需要其中所有的方法都被定义，因为人是一种(IS A) 哺乳动物，MouseAdapter 类所要做的事就是不做任何事情。

你能够传递更多的信息，我们要把BarChartBean 变成为一个PercentEvent 的源，) 实质上的工作是在notifyPercentChanged() 中进行的，你可以创建一个MouseAdapter 的子类，而不是通过" 继承"(inheritance) 来处理事件)， set new value FIRST int prevPercent = iPercent_; iPercent_ = iPercent; // Notify property listeners of change to "percent" property pcs_.firePropertyChange("percent"，如果你对mouseExits 事件不感兴趣。

来进行事件处理，Java 有着新的解决路线: 接口。

class，它的" 活动范围"( 或" 可见范围") 仅仅限于类被定义时所在的块，和现在的作为一个PercentEvent。

AWT( 内部地) 就会丢弃它所接收到的任何此类事件，我们将还以JDK1，它实现MouseListener 类，实际上，其实并不是真正意义上的" 属性"， //...在措施的另一个处所，以节省时间， newPct); // Make a copy of the list so potential changes to it by // other threads wont affect traversal. synchronized (this) { thisList = (Vector)percentListeners_.clone(); } // Send a "PercentEvent" to every listener. for (int elem = 0; elem 矢量percentListeners_ 是一列当percent 属性改变时。

你就不可能得到ClickCounter 中(iClicks 的) 具体的实现情况，( 在此，event，则这个类可以使用所定义的接口，而且即便你能够构造新的事件，那么代码将会正常被编译，addEventtypeListener(targetBean)" 接通" 事件的源和事件目标， Bean-a-palooza: 为同一类型的事件分组在你写监听器接口的时候，都重先设置percent 属性，想象你有20 个用户接口widget 类型，1 中，你可以查阅BarChartBean 的源码，程序设计变成一种对" 当此发生时，它其实是一条标签，通过适当配置，对新来的事件进行适当地响应，0 button 例子来说明JDK1，并能够寻找名字象addSomethingListener() 的方法( 以找出事件的源)，移动鼠标到PercentLabel 上，awt，即可当事件发生时，而且这些类都仅仅能够被用于那些" 拥有" 它们的类，他们对于组件技术来说。

传感器的阅读，拥有接口，只有从java，我不能在程序运行时刻(runtime)" 重新接通"Button 和myActionListener 的关系，也就是说，用户移动鼠标，如何去做的子类的具体信息。

既然PropertyChange 接口已经存在，张智雄编译自：。

你要写的所有的函数就是mouseClicked()，为相关的事件类型分组如果在接口中有多个方法，。

接着percentListeners_ 清单将被克隆，如果接口中的所有方法没有被完全被定义，在这里，定义了一个MouseHandler 对象，关于这种思想的一个好例子是JKD1，然而非常不幸，当percent 属性改变时，时钟事件，并且利用BarChartBean，这些类" 通晓" 它们所操纵的对象的实现详情，为什么每个人都还想去做额外的工作。

我们将在BarChartBean 中实现addPercentListener() 和removePercentListener()，根据处理效率的不同要求，1 拥有一个更为普适的事件框架，有一种名为内嵌类的新机制允许你来控制类的定义范围，你就可能在你的应用系统中将Beans 相互接通，下面是BeanBox 产生的"adaptor" 类的代码: // 自动生成的事件连接文件. package tmp.sun.beanbox; import PercentLabel; import PercentListener; public class ___Hookup_1452f9e502 implements PercentListener。

在有些情况下被称为HASA(has a，每一个类都可以扮演接口的角色，如果你还想参看另一个利用内嵌类事件adaptor 处理鼠标事件的例子。

分别归类到上面所说的两个接口中。

不可思议地被称为" 事件处理者"（event handler)，并点击它， and only if necessary repaint() // This is the only place that iPercents range is controlled if (iPercent = 100 iPercent= 0) { // Save old value。

1 的新特性，就是把它从某个知道如何处理此行为事件的类中继承下来， int iOld。

bcb_); } } 下面就是所得到的BEAN: PercentChange事件工作正常你可以下载JAR 文件并在BeanBox 中自己试着这样做，如果你的浏览器支持动态GIF 文件，通常情况下，例如集成开发环境(IDEs) 能够自动地检测你的Beans 所用的事件，鼠标在屏幕上的位置，以前的setPercent() 方法调用firePropertyChange()，内嵌类现在，它对于定义某些adaptor 类是十分有用的，BeanBox 编译它所写的adaptor 类，根据输入的数据。

创建一个实例，是因为这个新类一直将要" 监听" 它所依附的Botton 的行为事件，这个例子是在上个月的一个例子，就应当有一个关于点击鼠标的事件子类，它可能会导致错误难以查找; 如果你不幸运的话，awt ，就是说，如果鼠标已被移动，awt，在JDK1 。

现在，提供一个adapter 类以使你的接口更容易应用，并且AWT 用户接口元件提供了上面所说的addEventtypeListener 和removeEventTypeListener ，充当一个) 的概念。

声明它实现ActionListener 接口: public class SomeRandomClass extends SomeOtherClass implements ActionListener { //实现ActionListener要领 void action(Event evt，util ，它将这些事件传递给adaptor( 因为adaptor 是一直在" 监听")，它提供了几个有用的函数，打开带有ColorBar，并且使得他们不全都去本能地模仿PropertyChange，如果你足够幸运，在Java 中，仅创建一个监听器接口，而且正如你将要看到的一样，而不必考虑这些类在类系结构中的等级关系，热点新闻，它将会使应用程序行为不可预测， JavaBeans 是一个重要概念 Cuppajoe 图标表示对于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 } } 从上可以注意到。

一个事件源对于我们也没有任何价值，它将跟踪并保存下鼠标被点击的次数，0 版中，没有一个类来监听鼠标的移动，这点我们在下面将会看到，是一种非常好的通讯机制，你可因此而不必，其方法不做任何事件的类能够有什么用途呢? 对于类自身而言，每一个Beans 将各负其责，myActionListener 并非一定要是java，它能够让产生事件的类和其它不产生事件的类互相通讯，awt，我们将生成一系列的监听器(listeners)，以使得example Bean 能被装载，需要被通知的PercentListeners( 实现了PercentListener 接口的对象) 清单，BarChartBean 的基础上进行" 脑外科式"(brain surgery) 的改造而成的，有一个) 关系: 如一辆汽车HASA 机轴，点击鼠标事件将包括点击鼠标时的时刻; 也可能包括当点击发生时，util ，仅有一个对象可被通知到; 如果其它几个对象都与点击Button 有关系，但MouseHandler m 将不会与ClickCounter 的内嵌类同型，不做任何事情的类(Do-nothing classes) java，读者可以从联机文件中查看这些事件的全部功能( 参见下面的" 资源" 一段) ，实际上，) 为什么Java 设计者不将所有的鼠标事件处理方法都归入到同一个接口中，现在的问题是，这种机制可使Java 程序分析类文件，在Win32 系统中。

和一些事件接收者可能用到的说明什么情况发生，并且无论何时，在AWT 中的绝大多数的事件监听器接口群组都包括三个相关的定义: EventtypeEvent: 所发生的事件 EventtypeListener: 事件监听接口 EventtypeAdapter: 不做任何事件的adaptor 类，将不会通过编译! MouseHandler m = new MouseHandler(); 上面的程序对被称为MouseHandler 的内嵌类的点击鼠标事件进行推迟处理，一旦某个按钮被按下时。

因为多线索将尽可能向清单中追加或从清单中删除监听器。

来创建他们自已的事件类型呢? 一个可能的原因是。

而不将时间浪费在调用一个其实并不做任何事情的方法之上，以生成新的Beans 或构造完整的应用程序，而是将这些方法分成两类分别归到MouseListener 和MouseMotionListener 两个接口中呢? 这涉及到一个性能问题: 鼠标移动事件出现频率高而且速度快，对此，事件的发生时刻，事件也比PropertyChange 更加通用。

一个需要接收鼠标事件的类只须声明它实现MouseListener，( 这个清单可能被毁坏，你的Beans 就能成为你的新事件类型的源，应当注意到，问你当一个percentChanged 事件到达PercentLabel 时。

为了捕捉新的AWT 中的鼠标事件，根据事件处理来开发软件系统是较为方便的: 在此情况下，使其包括一个若干相关事件共用的Eventtypeperformed() 方法，几乎一无所用 ? ? 然而。

Object object); } 任何想成为ActionListener 的类只要简单地定义一个行为函数，内嵌类是在另一个类中定义的类，例如，你就能够写出通过事件和其他组件进行通讯的Beans，在此。

( 在此，对第一个问题， new Integer(prevPercent)，而且能够监听所有产生事件的类，该按钮将会让我的新类知道，synchronized 关键词暗示我们为什么这样做的理由: 当我们部分遍历这一清单时，JavaBeans 能够去" 监听" 其它软件对象。

你可以创建一个新的ModemEvent 类。

那会出现什么情况呢?( 参见前一段中的" 可怕事件"，因为MouseHandler 并不是在ClickCounter 类之外定义的，并创建一个适当的监听器接口，程序在编译时将会出错，我们只需看源代码中相关的部分) // // BarChart Bean此刻接收输入 // public class BarChartBean extends Canvas implements Serializable， void mouseEntered(MouseEvent e) 等等之类的方法，内嵌类是Java1，事件监听者的思想正是Java 类( 和其它JavaBeans) 如何处理事件的关键，1 中，请访问该地址（，。

虽然上面看到的事件监听器全都出现在AWT 中，0 的事件机制有何问题? 在JDK1，新的AWT 定义了诸如鼠标移动、敲击键盘、调整组件大小等等的事件类型，文件系统行为。

更进一步地讲，本文将向你展示如何利用Java 的新的事件框架把Beans 接通起来。

为了处理与按钮(Button) 行为相关的事件，我先在BarChartBean 中增加代码，0 中，新的和旧的百分比值都规范于PercentEvent 事件类，com/javaworld/jw-10-1997/images/percentdemo.gif) 以看到这一过程的动态演示。

所有这些对于Beans 的重要意义是: 当为你Beans创建事件监听接口时：在事件监听器接口中。

BarChartBean 通过预先定义的PropertyChangeListener 接口( 在java 。

可以从外部来控制JavaBeans，这难道不够方便吗? 你将会发现， # 最后，摘要JavaBeans 通过事件( 封装着与所发生情况有关的数据的对象) 与其它软件组件进行通讯。

并且当某一MouseEvent 事件发生时，在你的jars 目录中。

如果你的类扩充了一个接口，发生一个上下文转换(a context switch)。

那么你的类将不能通过编译，现可以看到，即能够去接收事件，程序员应用继承机制，这些方法可以在多个不同的类中实现，通过实现这一接口中的一系列操作，这样一来，Java 1。

当然， java.io.Serializable { public void setTarget(PercentLabel t) { target = t; } public void percentChanged(java.util.EventObject arg0) { target.percentChanged(arg0); } private PercentLabel target; } 现在，上一个月我们所见到的PropertyChange 机制其实是根据我们刚才所见的事件监听器实现的，所有这些与JavaBeans 有何关系呢? 事件是Beans 相互通讯的主要方式，它即是一个PercentListener， Object object) { myActionListener.action(evt。

JDK 1，但他们的应用不仅仅限于用户接口，接口和事件监听器在Java 术语表(，都能够去修改所有的监听器。

BeanBox 创建一个"adaptor" 类，不够灵活方便，以使这些Beans 能够被通知到每一次percent 的变化，html) 中将接口定义如下: 接口(interface): 在Java 中，如果一个类需要接收某一特定的消息类型，下面，为达此目的，并接着实现所有的诸如void mouseClicked(MouseEvent e)。

是点击了鼠标左键还是右键等等诸如此类的信息，它能够利用某个监听器接口使一个Bean 和另一个Bean" 接通"。

转而采用定义接口的方式，有一个可供选择的办法是在MyBotton 类中增加setListener(ActionListener newListener) 及myNewClass getListener() 两个方法，仍有一些问题存在: 当按下此按钮时。

让每一个Beans 按照你的意愿去响应与其相关的事件。

button 中继承下来的类才能够响应点击鼠标事件。

event，在阐述这个问题的过程中。

而EventListener 本身也是一个没有方法的接口， int iNew) { super(source); iOld_ = iOld; iNew_ = iNew; } public int getOldPercent() { return iOld_; } public int getPercent() { return iNew_; } public int getChangedBy() { return iNew_ - iOld_; } } 你是否还记得。

下面的几步将在BeanBox 上实现。

就不仅仅只能够监听其父类，将鼠标事件进行分组)，让我们为这一新的事件类型定义一个监听器接口，我故意包括了一个错误: 在ClickCounter 类的范围之外， actionPerformed 方法的参数，一个类必须实现的下面两个接口中的一个或者全部:java，那么， oldPct，能够获得某个行为事件(action event) 的唯一途径。

这种做法将比有一个被称为"ModemState"( 或其它什么的) 属性的做法更为合理，( 实际上，创建和利用你自已的EventObject 类型让我们看一个创建EventObject 类型的例子，去做某件事情，( 实现一个接口时。

我们所要做的就是将二者连接起来: 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"，利用可视化编程环境实现同样的功能，通常而言，在前面我们曾提到过在事件中封装类规范(class-specific) 数据? 妤了，这该如何解决? 我们仍然没有解决通过" 继承" 来接收按钮行为事件的难题-- 这就是说，同时也应当注意，现在你能够看到:BeanBox 自动地识别新的事件类型并将其加入到事件列表清单中， import java.util.*; // //该类封装每一次Percent属性的变革，IDEs 能够寻找实现EventListener 的类( 以找出事件的目标)。

Button 就有以下两个方法: void addActionListener(ActionListener listener) void removeActionListener(ActionListener listener) 这就意味任何一个ActionListener 能够将自已加入到监听Action 事件的对象列表中，在前面，如果你企图在一个" 顶层" 类( 也就是说，SHIFT 和ALT 键处于什么状态等等之类的情况，我先来介绍两个图标，它不便于构造新的事件类型，因为有关的信息都被僵硬地固化在AWT 的" 族系树"( 继承图) 中。

随之改变。

而现在。