Java事件机制理解及应用
1．从总体看事件机制
其实事件机制是一种处理世界的方式和方法。传统的顺序程序设计总是按照流程来安排所做的工作，而事件机制的特点在于：等待，如果有事情发生则处理之。这样的好处是顺序程序设计在没有事情做的时候也必须循环运行，做毫无效率的空的循环工作。而事件机制在没有事情的时候则可以不做任何事情的等待，从而可以释放各种资源用于其它需要的程序。其实，这和计算机的中断处理是一个想法和道理的。
事件总是和某个对象相关，即每个事件必须有一个事件源。比如，按纽按下事件必须和某个按钮相关，而绝对不会出现了一个按纽按下事件，但是没有任何按钮存在。
同时，某个事件发生了，则可能该事件会引起一些相关效果，也可能虽然发生，但不产生任何效果。即事件发生可能会被处理，也可能不会被处理。
处理一个事件的操作，可以由事件发生的事件源进行，而更多的可能是由其它对象来进行。比如，在一个窗口中的“退出”按钮被按下，该事件引起窗口的关闭，这个关闭的操作必须由窗口，而不是该按钮来进行。
事件机制中，操作事件发生后进程的主体并不会不断地查询事件是否发生，而应该等待事件源在事件发生时通知它该事
件发生了。如窗口并不会不断地查询“退出”按钮是否按下，而应该在“退出”按钮按下事件发生时由该按钮通过某种方式来通知窗口事件发生了。
对于事件源而言，需要知道其事件发生的主体可能没有，可能有一个，也可能有多个。所以，当事件发生时，一般性地“说”：事件发生了，并给出事件发生的相关信息是事件源的责任，但哪些主体需要得到该通知则不是事件源的责任，而是其它主体的责任。即：需要监控某个事件源事件是否发生的主体必须负责监听事件源事件是否发生。
同一个事件源可以发生多种事件，同一类事件可以由不同的事件源引起。比如，按纽可以发生“按下”、“释放”、“获得焦点”等多个事件。而“获得焦点”事件也可以由按钮、窗体、列表框等多个事件源引起。
因此，事件处理机制必须表达和处理好这么几个东西：事件源，描述可能引起事件的对象的所有属性，包括在事件发生时发出通知。事件，描述和处理事件的所有信息。主体，负责对其关心的事件发生后的处理。事件监听，负责监听主体关心的事件源是否发生相关的事件，并在事件发生时将事件的信息传递给主体。
2．Java的事件处理机制概览
根据事件处理机制的总体情况，Java从总体上采用了四个对象（类）来完成对事件的处理。
事件源类：描述事件发生源的基本属性和行为。比如，按钮是很多事件发生的事件源，Java构造按钮类来描述按钮的形状，颜色等等属性以及在屏幕上绘制按钮等动作，当然也包括按钮按下等相关事件发生本身。同时，在事件发生时，事件源类还负责发出事件发生的通知。该行为通过事件源查找自己的事件监听者队列，并将事件信息通知队列中的监听者来文成。同时，事件源还在得到有关监听者信息时负责维护自己的监听者队列。
事件类：描述某个事件的所有属性和相关动作。比如定义键盘事件类KeyEvent来描述键盘事件的所有信息，如键是否按下、是否释放、是否双击，以及相关键的信息，如键码，是否有组合键等等。
事件监听者类，也就是关注事件的主体类：当事件发生后，该主体负责进行相关的事件处理，同时，它还负责通知相关的事件源，自己关注它的特定的事件，以便事件源在事件发生时能够通知该主体。
事件监听者接口：事件发生后，事件源要将相关的信息通知对应的监听者。这要求必须在事件源和监听者之间定义一个标准的接口规范，以便完成这样的信息交换。监听者接口正是负责定义这样的接口规范。
这四种类的实现有以下一些比较关键的地方。
事件源的监听者队列的维护。通常可以通过定义一个可以接
受任何对象的队列来完成。因此，事件源应该至少做这么三件事：定义队列，通常通过定义一个Vector实例来接收和存储Object类型的监听者；定义添加监听者的方法，通常通过定义由监听者调用的addXXXListener方法完成向Vector队列中添加监听者；定义删除监听者的方法，通常通过定义由监听者调用的removeXXXListener方法来删除Vector队列中记录的监听者。
事件源事件的通知。在事件源发生某个事件后，事件源构造相应的事件类的实例，并在监听者队列中查找所有记录的监听者，并调用监听者对应的事件处理函数从而达到通知监听者的目的。这里，为了顺利地完成这种通知和调用，必须事先约定好这个处理函数接口。这种约定是由监听者接口来进行的。即在监听者接口中申明这些接口函数的名称和参数，而由监听者应用这些接口，并实现接口中的接口函数来完成。所以，接口函数实际上也就是监听者的对应事件的处理函数，在事件发生后监听者需要进行的操作都应该在这个函数中实现。同时，为了获得事件的信息，通常这样的接口函数都会传递对应的事件类参数。当然，也可以在接口中定义其它需要传递的参数。事件源构造对应的事件实例，并调用接口程序完成参数传递和事件通知。因此，在事件源中，需要编写相应的代码来完成事件队列的查询和接口函数的调用。
在Java中，由于应用接口必须在应用的类中实现接口中的所有申明函数，有时对于不需要使用所有申明函数的监听者比较麻烦，所以通常可以编写一个基础的适配器类来应用接口，适配器中预先实现所有的空接口函数，监听者则通过继承适配器并重载自己需要的接口函数来避免直接应用接口的麻烦。
在Java的类库中，提供了大多数常用的事件源、事件类、接口类及适配器类，因此实际使用中，只要在主体也就是监听者中应用接口或适配器，并实现相应的事件处理函数，然后利用addXXXListener添加相应的事件源的监听器，就完成事件机制的使用了。
当然，如果编制了自己的新事件源类，并且需要实现在Java 类库中没有预先实现的事件，则还需要编制自己的事件类（通常派生自EventObject），编制相应的事件接口类（通常派生自EventListener）并预定义相应的接口函数，在事件源类中实现相应的addXXXListener方法和removeXXXListener 方法，并完成对监听者队列的管理和事件通知代码的编写。3．事件处理机制的联想
其实，在事件发生时，事件源通知监听者，其本质还是要在此时调用监听者的相应处理函数。在C和C++中，可以直接在事件源类中定义相应的处理函数指针，并在监听者类中将事件源类的指针指向自己的相应函数就完成了。当然，如果
要实现多个监听者的监听，也可以在事件源中定义函数指针队列，并利用函数相应的函数来将相应监听者类的函数指针赋给队列元素，这样的处理方式就和前述方式相似的。
事件类的更多的目的是封装事件的相应信息，并方便在基础的事件类上的派生和重用。如果事件很简单，并且不存在继承等问题，其实可以不用构造事件类，直接简单地在事件源类中给出相关的事件信息就可以了。
同样，接口类也是为了申明监听者的事件处理函数的接口规范，并方面继承和代码重用。如果监听者固定且简单，也可以直接在监听者类中定义事件处理函数，而事件源直接调用就行了。
不过，专门定义事件类和接口类，能够使事件处理机制规范化，并且对于代码重用很有好处。在C和C++中，其实也可以按照类似的方式来考虑和组织事件处理机制。
4．事件处理机制的扩展应用
当我们定义我们自己的工具类库时，完全可以参照上述机制来组织我们自己的事件处理。这里，我们自己定义的类库应该是我们的事件源，而以后使用这个类库的应用程序则是监听者。在类库定义时，我们可以同时定义与该类库相关的事件类来封装事件的信息，也同时定义相应的接口类来申明监听者事件处理函数的接口规范，以及相应的适配器类来减少应用接口的麻烦。当然，为了提高代码的重用性，并且考虑
到Java的相关语法规定，上述四个类必须都申明为public，所以必须分别写在各自与类名相同的文件中，但应该申明为同一个包。
下面，我们以常见的计算工具为例，说明如何自己建立自己的事件处理机制。
考虑我们可能会建立很多各种不同的计算工具，比如常规的优化计算工具（各种优化方法），遗传算法计算工具，微粒群算法计算工具等等。这些工具都是事件源，它们可能发生的事件包括：计算完成事件、计算放弃事件和单步计算完成事件（每计算完一步，但还没有完成所有计算就发生该事件）。为了能够方便这些计算工具的开发，我们可以组织一个所有这些计算工具的父类组织，包括抽象的计算类，计算事件类，计算事件接口类，计算事件适配器类来搭建所有这些工具的计算事件处理框架。一旦框架完成，具体的计算工具类使用时我们就和使用比如Java类库中的窗口、按钮等类一样，只需要应用程序中注册监听者，实现事件处理函数，然后进行计算就行了。具体的代码如下。
import java.util.*;
public class CalTst { //测试应用程序，即具体的监听者
public static void main(String[] arg) {
System.out.println("Test Begin:");
myCal1 c1=new myCal1(); //申明计算工具1的实例
c1.addCalListener(new myCal1Adapter()); //注册工具1的监听者
c1.Run(); //运行工具1
myCal2 c2=new myCal2(); //申明工具2的实例
c2.addCalListener(new myAdaper()); //注册工具2监听者
c2.Run(); //运行工具2
}
}
class CalEvent extends EventObject { //计算工具事件类
public static final int STEPOVER=1; //申明事件标志，单步计算完成
public static final int CALOVER=2; //计算完成标志
public static final int CALCANCEL=3; //计算取消标志
public static final int TYPEERROR=-1;
protected long StepNum; //单步计算的步数
protected int Type; //事件类型
public CalEvent(Object src) { //几个事件构造函数
super(src); //登记事件源
Type=TYPEERROR;
}
public CalEvent(Object src, int mask) {
super(src);
if(mask==STEPOVER || mask==CALOVER || mask==CALCANCEL) Type=mask;
else Type=TYPEERROR;
}
public CalEvent(Object src, int mask, long step) {
super(src);
if(mask==STEPOVER || mask==CALOVER || mask==CALCANCEL) Type=mask;
else Type=TYPEERROR;
StepNum=step;
}
//一些实用方法
public void setType(int mask) { Type=mask; }
public void setType(int mask, long step){Type=mask; StepNum=step;}
public int getType() { return Type; }
public long getStepNum() { return StepNum; }
public boolean isStepCal() {
if(Type==CalEvent.STEPOVER) return true;
else return false;
}
public boolean isCalOver() {
if(Type==CalEvent.CALOVER) return true;
else return false;
}
public boolean isCalCancel() {
if(Type==CalEvent.CALCANCEL) return true;
else return false;
}
}
interface CalListener extends java.util.EventListener { //事件接口类
public boolean StepProformed(CalEvent event); //申明单步运算函数接口
public void CalOverProformed(CalEvent event); //申明计算完成函数接口
public void CancelProformed(CalEvent event); //申明计算取消函数接口
}
class CalAdapter implements CalListener { //事件适配器类，实现3个空处理函数
public boolean StepProformed(CalEvent event){return true;}
public void CalOverProformed(CalEvent event){}
public void CancelProformed(CalEvent event){}
}
class Calculation { //计算类，实际的计算事件源
protected Vector listener; //监听者队列
public Calculation(){ listener=new Vector(); }
public synchronized void addCalListener(CalListener l) { listener.add(l); }//添加监听者
public synchronized void removeCalListener(CalListener l){listener.remove(l);}
public boolean notifyEvent(int mask) { //事件通知函数重载版本1
Vector l=new Vector();
l=(Vector)listener.clone();
boolean rt=true;
CalEvent ev=new CalEvent(this);
if(mask==CalEvent.STEPOVER)
ev.setType(CalEvent.STEPOVER,0);
else ev.setType(mask);
synchronized(this) { //多线程锁定
for(int i=0; i<l.size(); i++) { //查询监听者，并调用处理函数
if(ev.isStepCal())
rt=((CalListener)l.elementAt(i)).StepProformed(ev);
else if(ev.isCalOver()) ((CalListener)l.elementAt(i)).CalOverProformed(ev);
else if(ev.isCalCancel()) ((CalListener)l.elementAt(i)).CancelProformed(ev);
}
}
return rt;
}
public boolean notifyEvent(int mask, long step) { //事件通知函数重载版本2
Vector l=new Vector();
l=(Vector)listener.clone();
boolean rt=true;
CalEvent ev=new CalEvent(this);
if(mask==CalEvent.STEPOVER)
ev.setType(CalEvent.STEPOVER,step);
else ev.setType(mask);
synchronized(this) {
for(int i=0; i<l.size(); i++) {
if(ev.isStepCal())
rt=((CalListener)l.elementAt(i)).StepProformed(ev);
else if(ev.isCalOver()) ((CalListener)l.elementAt(i)).CalOverProformed(ev);
else if(ev.isCalCancel()) ((CalListener)l.elementAt(i)).CancelProformed(ev);
}
}
return rt;
}
}
class myCal1 extends Calculation { //计算工具1类
public void Run() { //运行工具1方法
for(int i=0; i<5; i++)
notifyEvent(CalEvent.STEPOVER,i);//产生单步事件
notifyEvent(CalEvent.CALOVER); //产生计算完成事件
}
public String getResult(){ return "OK"; } //返回计算完成结果
}
class myCal1Adapter extends CalAdapter { //计算工具1适配器
public boolean StepProformed(CalEvent e) { //单步事件处理函数
System.out.println("Step "+e.getStepNum());
return true;
}
public void CalOverProformed(CalEvent e) { //计算完成处理函数
System.out.println("The Result is
"+((myCal1)e.getSource()).getResult());
}
}
class myCal2 extends Calculation { //计算工具2类
public void Run() { //计算工具2运行
notifyEvent(CalEvent.CALOVER); //产生计算完成事件
}
}
class myAdaper extends CalAdapter { //计算工具2适配器
public void CalOverProformed(CalEvent e) {//计算完成处理函数
System.out.println("The Source is
"+e.getSource().toString());
}
}
运行上述例程，可以获得如下结果：
Test Begin:
Step 0
Step 1
Step 2
Step 3
Step 4
The Result is OK
The Source is myCal2@7259da
可以看出，应用程序利用注册的监听器及其事件处理函数，
完全获得了计算事件对应的运行结果。这种事件处理框架完全可以应用于我们自己的计算类工具库中。
实验五Java事件处理 实验目的 1.掌握Java语言中的事件处理方法 2.掌握Java语言中事件源、监视器和处理事件的接口的概念 实验内容 1.图形用户界面设计程序(ArtFo nt.java) 在实验三第1题的基础上，添加事件处理机制，并逐步完善程序功能。分别用ArtFont 类的对象做监视器和匿名内部类的对象做监视器实现。 要求实现如下功能： 当在文本框中输入文字后回车，在文本域中显示输入的文字。当分别选择粗体和斜体 复选框时，文本域中的文字分别显示粗体和斜体样式。 当点击颜色按钮时，出现颜色选择对话框，选择需要的颜色，按确定按钮后，按钮的 前景色和文本域的前景色设置为选定的颜色。 当选择字体样式下拉框中的某一字体样式时，文本域中的文字设置为指定的字 体样式。 当选择字体大小下拉框中的某一字体大小时，文本域中的文字设置为指定的字 体大小。 当选择窗体样式下拉框中的某一窗体效果时，窗体外观改变为指定的窗体外观。 图1程序界面运行效果 package Sy; import java.awt.*; import java.awt.event.*;
import javax.swing.*; public class ArtFont extends JFrame { static ArtFont artFont; JComboBox fontType;// 字体样式下拉框 JComboBox fontSize;// 字体大小下拉框 JComboBox windowStyle;// 窗体样式下拉框 JCheckBox boldBx;// 粗体按钮 JCheckBox italicBx;// 斜体按钮 JButton colorBtn;// 颜色按钮 String[] fontNames;// 字体名称 String[] fontSizes;// 字体大小 JLabel label;// 输入提示标签 JTextField inputText;// 文字输入框 JTextArea txtArea;// 文字显示区 JPanel northPanel;// 字体设置 JPanel centerPanel;// 显示效果区 JPanel southPanel;/样式设置 Font font; int boldStyle, italicStyle; int fontSizeStyle; String fontNameStyle; Color colorStyle = Color.black;// 设置字体的默认颜色为黑色 String[] style = { "默认显示效果 ", "Windows 显示效果 ", "Unix 显示效果 " }; public ArtFont() { super(”字体设置"); // 设置默认字体 boldStyle = 0; italicStyle = 0; fontSizeStyle = 10; fontNameStyle = "宋体 ";
代码如下，注意注释： import java.awt.Container; import java.awt.event.*; import javax.swing.*; public class ShortTest2 extends JFrame implements ActionListener { JButton jb1; JPanel j1; public ShortTest2() { Container contentPane = this.getContentPane(); j1 = new JPanel(); jb1 = new JButton("Draw"); jb1.addActionListener(this); j1.add(jb1); contentPane.add(j1, "North"); } public static void main(String[] args) { ShortTest2 m = new ShortTest2(); m.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); m.setSize(600, 370); m.setLocationRelativeTo(null); m.setVisible(true); } public void actionPerformed(ActionEvent ae) { //主要是这里，按钮一按就执行下面的代码 JOptionPane.showMessageDialog(null, "Hello World!"); } } java点击按钮，出现另一个窗口 第一个窗体LoginFrame.java：
J a v a S w i n g中处理各组件事件的一般步骤 集团标准化办公室：[VV986T-J682P28-JP266L8-68PNN]
Java Swing中处理各组件事件的一般步骤是： 1．新建一个组件（如JButton）。 2．将该组件添加到相应的面板（如JPanel）。 3．注册监听器以监听事件源产生的事件（如通过ActionListener来响应用户点击按钮）。 4．定义处理事件的方法（如在ActionListener中的actionPerformed中定义相应方法）。 以上步骤我们可以用多种方法实现。但人们通常用二种方法。第一种方法是只利用一个监听器以及多个if语句来决定是哪个组件产生的事件；第二种方法是使用多个内部类来响应不同组件产生的各种事件，其具体实现又分两种方式，一种是匿名内部类，一种是一般内部类。 为了说明如何使用上述三种方法实现事件的处理方法，我们建立一个简单的应用程序。该程序界面有两个按钮，当用户点击相应的按钮，就会弹出一个对话框显示相应的内容。通过这个简单程序，你可以实现自己更多、更复杂的用户界面程序。 首先，我们利用单个监听器来实现该程序。我们定义一个名为Simple1的类来包括所有代码。所有的用户行为（如点击按钮）由一个监听器SimpleListenner中的actionPerformed方法来处理。以下是代码： import .*; import .*; public class Simple1 {
private static JFrame frame;dd(myPanel); (); (true); } } 让我们来看看以上代码是如何工作的。在main方法中，我们定义了一个JFrame，然后将面板Jpanel添加到窗体中，该面板包括两个按钮。相应的变量Frame,button1,button2定义在程序的开头部分。 在程序入口main方法中，首先新建Simple1组件，通过构造器建立用户GUI，定义一个面板Jpanle,，增加两个按钮，然后利用将两个按钮加入到一个活动监听器SimpleLister中，最后，两个按钮添加到面板。当GUI 建立后，我们将面板添加到窗体并显示结果。当用户点击按钮时，程序调用actionPerformed方法，通过if语句来判断是哪一个按钮被点击，然后在对话框中显示相应的内容。 利用一个监听器来处理事件的缺点是，当程序比较复杂时，需要一大串的if 语句来实现，程序代码较难阅读与维护。当然，如果处理的事件较少，这种方式比较简单。 通过使用匿名内部类可以解决上述存在的问题。使用简单的匿名内部类作为addActionListener的变量即可。以下是实现代码：
Java講座（七） Java and Event Handling 圖文?李盈嫻（ Luna Lee ） 一、前言 在上一個章節，我們做出了美美的圖形使用者介面，可是，我們做的圖形介面要怎樣才能跟使用者產生互動呢？例如當使用者按下按鈕或移動滑鼠時，程式要做出什麼相對應的動作，畫面會產生什麼變化等等。在此，我們就要藉由『Event Handling』的觀念來完成。本章將會介紹Event的基本觀念，Listener的實作方法，最後並應用到聊天室的範例上。 二、內容 什麼是Event 當我們在寫程式時，多半會需要與使用者互動或回應其指令。在古早古早的以前，若有一支程式想要回應使用者按下滑鼠的動作，可能得要辛苦的寫一大堆code自己去抓相關的資訊。例如，在這支程式被initial 了之後，就要有一支迴圈不斷地去檢查使用者的滑鼠到底被按下去了沒有。這種polling programming的方法，一來浪費系統資源，二來所有要處理的回應與動作都在一個大迴圈中而顯得複雜了許多。 而Java的AWT則採用event-driven programming的方法來達成此目的，當某個特定的事件發生，就會驅動程式去執行某些特定的動作，而可與使用者產生即時的互動。其中有三個要素： ?Event – 意指某個特定的事件、動作，也就是「發生了什麼事件」。例如：視窗關閉、滑鼠移動。 ?Event Source – 產生、觸發事件的元件。例如：Button、TextField。?Event Handler – 負責接收Event object並作處理的Method。 在Java中把Events以物件來表示，並依type分類為不同的classes。有些負責表示較高階的事件(元件本身狀態或內容的改變)，如ActionEvent、TextEvent；有些則表示較低階的事件(元件與環境間的溝通，像鍵盤或滑鼠相關的動作)，例如KeyEvent、MouseEvent。而除DocumentEvent外，所有event classes的super class皆為java.util.EventObject。 我們在(圖1) 列舉了一些在GUI程式設計中常見，重要的Event classes及其階層關係。(讀者若有需要，也可自行查閱Java API，看看還有哪些Event classes可用。 ) 圖1
Java Swing中处理各组件事件的一般步骤是： 1．新建一个组件（如JButton）。 2．将该组件添加到相应的面板（如JPanel）。 3．注册监听器以监听事件源产生的事件（如通过ActionListener来响应用户点击按钮）。4．定义处理事件的方法（如在ActionListener中的actionPerformed中定义相应方法）。以上步骤我们可以用多种方法实现。但人们通常用二种方法。第一种方法是只利用一个监听器以及多个if语句来决定是哪个组件产生的事件；第二种方法是使用多个内部类来响应不同组件产生的各种事件，其具体实现又分两种方式，一种是匿名内部类，一种是一般内部类。 为了说明如何使用上述三种方法实现事件的处理方法，我们建立一个简单的应用程序。该程序界面有两个按钮，当用户点击相应的按钮，就会弹出一个对话框显示相应的内容。通过这个简单程序，你可以实现自己更多、更复杂的用户界面程序。 首先，我们利用单个监听器来实现该程序。我们定义一个名为Simple1的类来包括所有代码。所有的用户行为（如点击按钮）由一个监听器SimpleListenner中的actionPerformed方法来处理。以下是代码： import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Simple1 { private static JFrame frame; // 定义为静态变量以便main使用 private static JPanel myPanel; // 该面板用来放置按钮组件 private JButton button1; // 这里定义按钮组件 private JButton button2; // 以便让ActionListener使用 public Simple1() // 构造器, 建立图形界面 { // 新建面板 myPanel = new JPanel(); // 新建按钮 button1 = new JButton("按钮1"); // 新建按钮1 button2 = new JButton("按钮2"); SimpleListener ourListener = new SimpleListener(); // 建立一个actionlistener让两个按钮共享 button1.addActionListener(ourListener); button2.addActionListener(ourListener); myPanel.add(button1); // 添加按钮到面板 myPanel.add(button2); }
Java的事件处理机制 概念部分： 1.事件：Event 是一种消息对象，封装了与事件发生相关的信息， 如操作键盘会引发KeyEvent事件， 单击关闭按钮会引发WindowEvent事件， 单击命令按钮或选择菜单项目会引发ActionEvent事件 等等 2.事件源：Event Source 产生事件的对象， 如命令按钮和单选按钮都是事件源，单击他们时，会引发ActionEvent事件 单选按钮会产生ItemEvent事件。 3.事件监听器：Event Listener 在事件发生时，事件源负责给予通知的一种对象。接收到事件通知的监听器主动的对事件进行处理。 两件事：将自己注册给事件源；事件的处理 4.事件处理器Event Handler 事件处理方法，用来接受事件并处理事件的方法。 Java事件处理的步骤： 1.类实现相应的事件监听器接口 2.重写接口中抽象方法 3.给事件源注册事件监听器 【例题】关闭窗口的实现
public class NotepadDemo{ private Frame mainForm; private MenuBar mb; private Menu m1; private Menu m2; private MenuItem mExit; private MenuItem mi1; private MenuItem mi2; private ExitHandler eh; public NotepadDemo(){ mainForm = new Frame(); mb = new MenuBar(); m1 = new Menu("文件(F)"); m2 = new Menu("编辑(E)"); mi1 = new MenuItem("新建 Ctrl + N"); mi2 = new MenuItem("打开 Ctrl + O"); mExit = new MenuItem("退出(X)"); mainForm.setMenuBar(mb); mb.add(m1); mb.add(m2); m1.add(mi1); m1.add(mi2); m1.add(mExit); mainForm.setBounds(0, 0, 400, 300); eh = new ExitHandler(); //注册事件监听器 mExit.addActionListener(eh); mi1.addActionListener(eh); mi2.addActionListener(eh); //注册Form的关闭监听器 mainForm.addWindowListener(eh); } public void NotepadShow(){ mainForm.setVisible(true); } public static void main(String[] args) { NotepadDemo nd = new NotepadDemo(); nd.NotepadShow();
教案首页（以2课时为单元）
事件处理 所谓事件，实际就是用户对程序的某一种功能性操作。自从JDK1.1以后，Java的事件处理模式都是以委托事件模式（Delegation Event Model）来处理用户所触发的事件。这就是说，当用户触发的事件不是我们想要的事件时，我们就不需要进行处理，这样就增加了系统的效率，整个事件处理结构也变得很清晰。 事件处理需要注意三个问题：第一是事件产生的来源（Source），也就是说什么组件要被处理。比如按钮Button被单击，则事件来源就是按钮；第二就是什么事件要被处理。一般来说事件是和组件相对应的，什么样的组件就会触发什么样的事件，而往往一个组件可能会触发多个事件，这就需要我们按具体情况进行设计。Java中的委托事件模式在此有要个规定，就是说需要对哪个组件进行事件处理，则必须给这个组件进行事件注册。一般来说这种注册很简单，基本都是用方法“addXXXListener”来注册，也就是给组件加上事件监听器。比如按钮组件就需要用addActionListener来进行注册；第三就是编写事件处理程序了，用户编程定义每个特定事件发生时程序应做出何种响应，并且这些响应代码会在对应的事件发生时由系统自动调用。比如按钮的事件处理我们都写在方法actionPerformed()中。 Java中的事件相关类基本都在java.awt.event包，它提供AWT事件所需的类和接口，我们把这些事件称为AWTEvent，并分为两大类：Low-level-Event和Semantic Event，前者指的是一些低层次的事件，后者指一些有意义的动作。为了使大家清楚AWTEvent事件结构 在此我们将以上事件类及其相关内容列表如下 AWT Event
第一篇 在JAVA程序设计中，事件的处理是非常重要的，尤其是在需要自定义事件和设计JavaBean 时.对事件的处理过程有一个完整的认识对于编程是很有帮助的。 下面用一个演示性的例子来说明事件及其处理过程 一.事件的组成 如果想要自定义一个事件，则必须提供一个事件的监听接口以及一个事件类。在JAVA 中监听接口继承java.util.EventListener,事件类继承java.util.EventObject.很多基本的事件在编程环境中都已经提供可以很方便使用，但是在自定义事件中必须要要了解这些。 下面是一个事件类的代码,事件类可以向用户处理程序提供被监听类的信息 import java.util.*; public class PropertyEvent extends EventObject { public PropertyEvent(){} } 下面是监听接口的代码 import java.util.*; public interface PropertyListener extends EventListener { public void propertyChanged(PropertyEvent propertyEvent); } 二.事件的处理机制 下面是一段简要的被监听类代码，通过代码分析事件处理过程 import java.util.*; public class Exam { private int property; //listeners用来存放已注册的监听对象 private Set listeners= new HashSet(); ..... public void addListener(PropertyListener propertyListener){ //listeners必须保证只能被一个线程访问 synchronized(listeners){ listeners.add(propertyListener); } } public void firePropertyChange(){ Iterator iterator; synchronized(listeners){ //将listeners中的类名放到iterator iterator = new HashSet(listeners).iterator(); }
实验五--Java事件处理
实验五 Java事件处理 实验目的 1．掌握Java语言中的事件处理方法 2．掌握Java语言中事件源、监视器和处理 事件的接口的概念 实验内容 1.图形用户界面设计程序(ArtFont.java) 在实验三第1题的基础上，添加事件处理机制，并逐步完善程序功能。分别用ArtFont 类的对象做监视器和匿名内部类的对象做监视器实现。 要求实现如下功能： ●当在文本框中输入文字后回车，在文本域 中显示输入的文字。 ●当分别选择粗体和斜体复选框时，文本域 中的文字分别显示粗体和斜体样式。 ●当点击颜色按钮时，出现颜色选择对话 框，选择需要的颜色，按确定按钮后，按 钮的前景色和文本域的前景色设置为选 定的颜色。 ●当选择字体样式下拉框中的某一字体样 式时，文本域中的文字设置为指定的字体 样式。 ●当选择字体大小下拉框中的某一字体大 小时，文本域中的文字设置为指定的字体 大小。 ●当选择窗体样式下拉框中的某一窗体效 果时，窗体外观改变为指定的窗体外观。
图1 程序界面运行效果 package Sy; import java.awt.*; import java.awt.event.*; import javax.swing.*; public class ArtFont extends JFrame { static ArtFont artFont; JComboBox fontType;//字体样式下拉框 JComboBox fontSize;//字体大小下拉框 JComboBox windowStyle;//窗体样式下拉框 JCheckBox boldBx;// 粗体按钮 JCheckBox italicBx;// 斜体按钮 JButton colorBtn;// 颜色按钮 String[] fontNames;// 字体名称 String[] fontSizes;// 字体大小 JLabel label;// 输入提示标签
低级事件与语义事件 AWT 提供了二种概念性事件类型：低级事件和语义事件。 低级事件代表屏幕上可视化组件的低级输入或窗口系统事件。AWT 定义的低级事件类如下： java.util.EventObject java.awt.AWTEvent https://www.doczj.com/doc/ea14550355.html,ponentEvent（组件改变大小，移动等） java.awt.event.FocusEvent（组件获得焦点，失去焦点） java.awt.event.InputEvent java.awt.event.KeyEvent（组件获得键按下、键释放等） java.awt.event.MouseEvent（组件获得鼠标按下、鼠标移动等） java.awt.event.ContainerEvent java.awt.event.WindowEvent 语义事件是在较高层次定义的，用于封装用户接口组件模型的语义。AWT 定义的语义事件类如下： java.util.EventObject java.awt.AWTEvent java.awt.event.ActionEvent（“执行命令”） java.awt.event.AdjustmentEvent(“值被调整”） java.awt.event.ItemEvent（“项目状态改变”） java.awt.event.TextEvent（“文本对象的值改变”） 注意这些语义事件不依赖特定的基于屏幕的组件类，但可以应用到实现类似语义模型的一套组件上。例如，Button 对象将在被按下时抛出“action”事件，List 对象将在双击其中项目时抛出“action”事件，当从菜单中选择MenuItem 时抛出“action”事件，而非可视化 Timer 对象在计时器到时时抛出“action”事件（后者为假设情况）。 事件监听器 EventListener 接口通常对于事件类代表的不同事件类型具有不同的方法。因此本质上，特定事件语义由 Event 类和 EventListener 中的特定方法合起来定义。例如，FocusListener 接口定义了两种方法，focusGained() 和focusLost()，分别用于 FocusEvent 类代表的两种事件类型。 该 API 试图提供一个合理的监听器接口类型数量而又不是为每种事件类型都提供单独的接口。 AWT 定义的低级监听器接口如下：
java 事件处理模型 当用户在Java GUI界面进行一些操作时，例如，移动鼠标、选取菜单项目等，将会引发相关事件（Event）。在Java中，事件用具体的对象来表示，用户的相关动作会由JVM（Java虚拟机）创建成相应的事件对象，用以描述事件来源、事件类型以及相关的信息。 1．事件处理流程 Java对事件的处理采用授权事件模型，也称为委托事件模型（Delegation Even t Model）。在这个模型下，每个组件都有相应的事件，如按钮具有单击事件，文本域具有内容改变事件等。当对于某个组件的事件被触发后，组件就会将事件发送给组件上注册的每一个事件监听器（EventListener），事件监听器中定义了与不同事件相对应的事件处理者，此时事件监听器会根据不同的事件信息调用不同的事件处理者，完成对这次事件的处理。只有向组件注册的事件监听器才会收到事件信息。 此种模型的显著特点是，当组件被触发事件后，本身不去处理，而将处理的操作交给第三方来完成。例如，当用户在GUI界面单击了一个按钮信息，此时按钮就是一个事件源对象，按钮本身没有权利对这次单击做出反应，需要做的就是将信息发送给本身注册的监听器（事件处理者）来处理。 在现实生活中，授权处理的实例也是非常的多。打个不太恰当的比喻，比如说有一位李先生，李先生可能会发生很多法律纠纷，可能是民事法律纠纷，也可能是刑事法律纠纷，那么李先生可以请律师，他可以授权王律师负责帮他打民事法律的官司，同时也可以授权张律师帮他打刑事法律的官司。 这个请律师的过程从李先生的角度来看，就是授权的过程，而从王律师和张律师的角度来看，一旦被授权，他们就得时刻对李先生负责，时刻“监听”李先生的事件信息，一旦发生民事纠纷了，王律师就要马上去处理，而一旦发生刑事纠纷了，张律师就要马上进行处理。此时此刻，李先生就是事件源，王律师是一个事件处理者，张律师是另外一个事件处理者，民事纠纷和刑事纠纷就是不同类型的事件。 2．事件处理元素 在事件处理的过程中，主要涉及三类对象，分别为事件、事件源和事件处理者。 Event事件 用户对界面的各种操作总是以类的形式出现，如键盘操作对应的事件类是Key Event。在授权事件模型中，事件是一个描述事件源状态发生改变的对象。通过鼠标、键盘与GUI界面直接或间接交互都会生成事件，如用户在文本框中键入文本后，按回车键，单击按钮，在一个下拉列表中选择一个条目等操作。
Java事件处理机制- 事件监听器的四种实现方式 自身类作为事件监听器 外部类作为事件监听器 匿名内部类作为事件监听器 内部类作为事件监听器 自身类作为事件监听器: Java代码复制代码收藏代码 import javax.swing.*; import java.awt.*; import java.awt.event.*; /** *Java事件处理机制:自身类作为事件监听器 *@author Winty(wintys@https://www.doczj.com/doc/ea14550355.html,) *@version 2008-12-3 */ class ThisClassEvent extends JFrame implements ActionListener{ JButton btn; public ThisClassEvent(){ super("Java事件监听机制"); setLayout(new FlowLayout()); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); btn=new JButton("点击"); btn.addActionListener(this); getContentPane().add(btn); setBounds(200,200,300,160); setVisible(true); } /**************************************/ public void actionPerformed (ActionEvent e){ Container c=getContentPane(); c.setBackground(Color.red); } /**************************************/ public static void main(String args[]){
实验五 Java事件处理 实验目的 1．掌握Java语言中的事件处理方法 2．掌握Java语言中事件源、监视器和处理事件的接口的概念 实验内容 1.图形用户界面设计程序(ArtFont.java) 在实验三第1题的基础上，添加事件处理机制，并逐步完善程序功能。分别用ArtFont类的对象做监视器和匿名内部类的对象做监视器实现。 要求实现如下功能： 当在文本框中输入文字后回车，在文本域中显示输入的文字。 当分别选择粗体和斜体复选框时，文本域中的文字分别显示粗体和斜体样式。 当点击颜色按钮时，出现颜色选择对话框，选择需要的颜色，按确定按钮后， 按钮的前景色和文本域的前景色设置为选定的颜色。 当选择字体样式下拉框中的某一字体样式时，文本域中的文字设置为指定的字 体样式。 当选择字体大小下拉框中的某一字体大小时，文本域中的文字设置为指定的字 体大小。 当选择窗体样式下拉框中的某一窗体效果时，窗体外观改变为指定的窗体外观。 图1 程序界面运行效果 package Sy;
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class ArtFont extends JFrame { static ArtFont artFont; JComboBox fontType;//字体样式下拉框 JComboBox fontSize;//字体大小下拉框 JComboBox windowStyle;//窗体样式下拉框JCheckBox boldBx;// 粗体按钮 JCheckBox italicBx;// 斜体按钮 JButton colorBtn;// 颜色按钮 String[] fontNames;// 字体名称 String[] fontSizes;// 字体大小 JLabel label;// 输入提示标签 JTextField inputText;// 文字输入框 JTextArea txtArea;// 文字显示区 JPanel northPanel;// 字体设置 JPanel centerPanel;// 显示效果区 JPanel southPanel;//样式设置
实验四Java事件处理 实验目的 1．掌握Java语言中的事件处理方法 2．掌握Java语言中事件源、监视器和处理事件的接口的概念 实验导读 1． Java事件处理简介 学习组件除了了解组件的属性和功能外，学习组件除了了解组件的属性和功能外，一个更重要的方面是学习怎样处理组件上发生的界面事件。当用户在文本框中输入文本后按Enter键、单击按钮、在一个下拉列表框中选择一个条目等操作时，都发生界面事件。在学习处理事件时，必须很好地掌握事件源、监视器、处理事件的接口这三个概念。 ●事件源： 能够产生事件的对象都可以成为事件源，如文本框、按钮、下拉式列表等。也就是说，事件源必须是一个对象，而且这个对象必须是Java认为能够发生事件的对象。 ●监视器： 需要一个对象对事件源进行监视，以便对发生的事件作出处理。事件源通过调用相应的方法将某个对象作为自己的监视器。例如，对于文本框，这个方法是： addActionListener(监视器); 对于获取了监视器的文本框，当文本框获得输入焦点之后，如果用户按Enter键，Java 运行系统就自动用ActionEvent类创建一个对象，即发生了ActionEvent事件。也就是说，事件源获得监视器后，相应的操作就会导致事件的发生，并通知监视器，监视器就会做出相应的处理。 ●处理事件的接口： 监视器负责处理事件源发生的事件。监视器是一个对象，为了让监视器这个对象能对事件源发生的事件进行处理，创建该监视器对象的类必须声明实现相应的接口，即必须在类体中给出该接口中所有方法的方法体，那么当事件源发生事件时，监视器就自动调用类实现的某个接口中的方法。 2．文本框上的ActionEvent事件 java.awt.event包中提供了许多事件类和处理各种事件的接口。对于文本框，这个接口的名字是ActionListener，这个接口中只有一个方法： public void actionPerformed(ActionEvent e) 当在文本框中输入字符并按Enter键时，java.awt.event包中的ActionEvent类自动创建一个事件对象，并将它传递给actionPerformed(ActionEvent e)方法中的参数e，监视器自动调用这个方法对发生的事件做出处理。
Java事件机制理解及应用 1．从总体看事件机制 其实事件机制是一种处理世界的方式和方法。传统的顺序程序设计总是按照流程来安排所做的工作，而事件机制的特点在于：等待，如果有事情发生则处理之。这样的好处是顺序程序设计在没有事情做的时候也必须循环运行，做毫无效率的空的循环工作。而事件机制在没有事情的时候则可以不做任何事情的等待，从而可以释放各种资源用于其它需要的程序。其实，这和计算机的中断处理是一个想法和道理的。 事件总是和某个对象相关，即每个事件必须有一个事件源。比如，按纽按下事件必须和某个按钮相关，而绝对不会出现了一个按纽按下事件，但是没有任何按钮存在。 同时，某个事件发生了，则可能该事件会引起一些相关效果，也可能虽然发生，但不产生任何效果。即事件发生可能会被处理，也可能不会被处理。 处理一个事件的操作，可以由事件发生的事件源进行，而更多的可能是由其它对象来进行。比如，在一个窗口中的“退出”按钮被按下，该事件引起窗口的关闭，这个关闭的操作必须由窗口，而不是该按钮来进行。 事件机制中，操作事件发生后进程的主体并不会不断地查询事件是否发生，而应该等待事件源在事件发生时通知它该事
件发生了。如窗口并不会不断地查询“退出”按钮是否按下，而应该在“退出”按钮按下事件发生时由该按钮通过某种方式来通知窗口事件发生了。 对于事件源而言，需要知道其事件发生的主体可能没有，可能有一个，也可能有多个。所以，当事件发生时，一般性地“说”：事件发生了，并给出事件发生的相关信息是事件源的责任，但哪些主体需要得到该通知则不是事件源的责任，而是其它主体的责任。即：需要监控某个事件源事件是否发生的主体必须负责监听事件源事件是否发生。 同一个事件源可以发生多种事件，同一类事件可以由不同的事件源引起。比如，按纽可以发生“按下”、“释放”、“获得焦点”等多个事件。而“获得焦点”事件也可以由按钮、窗体、列表框等多个事件源引起。 因此，事件处理机制必须表达和处理好这么几个东西：事件源，描述可能引起事件的对象的所有属性，包括在事件发生时发出通知。事件，描述和处理事件的所有信息。主体，负责对其关心的事件发生后的处理。事件监听，负责监听主体关心的事件源是否发生相关的事件，并在事件发生时将事件的信息传递给主体。 2．Java的事件处理机制概览 根据事件处理机制的总体情况，Java从总体上采用了四个对象（类）来完成对事件的处理。
Java常用方法大全 （方法与事件） 字符串 1、获取字符串的长度 length() 2 、判断字符串的前缀或后缀与已知字符串是否相同 前缀startsWith(String s) 后缀endsWith(String s) 3、比较两个字符串 equals(String s) 4、把字符串转化为相应的数值 int型Integer.parseInt(字符串) long型Long.parseLong(字符串) float型Folat.valueOf(字符串).floatValue() double型Double.valueOf(字符串).doubleValue() 4、将数值转化为字符串 valueOf(数值) 5、字符串检索 indexOf(Srting s) 从头开始检索 indexOf(String s ,int startpoint) 从startpoint处开始检索 如果没有检索到，将返回-1 6、得到字符串的子字符串 substring(int startpoint) 从startpoint处开始获取 substring(int start,int end) 从start到end中间的字符 7、替换字符串中的字符,去掉字符串前后空格 replace(char old,char new) 用new替换old trim() 8、分析字符串 StringTokenizer(String s) 构造一个分析器，使用默认分隔字符（空格，换行，回车，Tab，进纸符） StringTokenizer(String s,String delim) delim是自己定义的分隔符 nextToken() 逐个获取字符串中的语言符号 boolean hasMoreTokens() 只要字符串还有语言符号将返回true，否则返回false countTokens() 得到一共有多少个语言符号 文本框和文本区 1、文本框 TextField() 构造文本框，一个字符长