Java事件处理机制- 事件监听器的四种实现方式

常用事件及对应监听器和方法在Java中，事件是指程序运行过程中发生的一些特定行为或状态的改变。

为了对这些事件进行监听和处理，我们可以使用事件监听器和相应的方法。

下面是一些常用的事件及其对应的监听器和方法：1. ActionEvent（动作事件）监听器：ActionListener方法：addActionListener描述：当用户执行一些动作时（如点击按钮），触发ActionEvent事件，并调用相应的监听器方法进行处理。

2. KeyEvent（键盘事件）监听器：KeyListener方法：addKeyListener描述：当用户按下或释放一些键时，触发KeyEvent事件，并调用相应的监听器方法进行处理。

3. MouseEvent（鼠标事件）监听器：MouseListener、MouseMotionListener方法：addMouseListener(、addMouseMotionListener描述：当用户在组件上执行鼠标操作（如点击、拖动等）时，触发MouseEvent事件，并调用相应的监听器方法进行处理。

4. WindowEvent（窗口事件）监听器：WindowListener、WindowStateListener方法：addWindowListener(、addWindowStateListener描述：当窗口的状态发生改变（如打开、关闭等）时，触发WindowEvent事件，并调用相应的监听器方法进行处理。

6. ItemEvent（选项事件）监听器：ItemListener方法：addItemListener描述：当选择框、复选框等选项发生改变时，触发ItemEvent事件，并调用相应的监听器方法进行处理。

7. FocusEvent（焦点事件）监听器：FocusListener方法：addFocusListener描述：当组件获得或失去焦点时，触发FocusEvent事件，并调用相应的监听器方法进行处理。

Java实现⼀个简单的事件监听器关于事件监听我们需要知道的⼀些基础知识。

a)事件三要素（who when what）：source -- 事件源when -- 事件发⽣时间message -- 事件主题消息，即希望通过事件传递出去的信息b)事件模型的构成：event -- 事件source -- 事件源listener -- 事件监听器c)事件流转过程：（1）事件源注册监听器 -> （2）事件发⽣ -> （3）通知监听器 -> （4）监听器处理那么基于以上背景知识，我们来是实现⼀个简单的监听器，并测试⼀下事件监听的完整流程。

根据事件三要素设计出⼀个简单合理的事件载体：Eventpublic interface Event extends Serializable {Object getSource();Date getWhen();String getMessage();/*** 事件回调⽅法*/void callback();}事件实现：MyEventpublic class MyEvent implements Event {private Log log = LogFactory.getLog(getClass());private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");private Object source;private Date when;private String message;@Overridepublic Object getSource() {return source;}public void setSource(Object source) {this.source = source;}@Overridepublic Date getWhen() {return when;}public void setWhen(Date when) {this.when = when;}@Overridepublic String getMessage() {return message;}public void setMessage(String message) {this.message = message;}@Overridepublic void callback() {(toString());}@Overridepublic String toString() {return "source: " + getSource() + ", message: " + getMessage() + ", when: " + sdf.format(getWhen()); }}View Code监听器接⼝：EventListenerpublic interface EventListener {/*** 事件触发* @param event*/void handleEvent(Event event);}监听器实现：MyListenerpublic class MyListener implements EventListener {@Overridepublic void handleEvent(Event event) {event.callback();}}事件源接⼝：EventSourcepublic interface EventSource {/*** 增加监听器* @param listener*/void addListener(EventListener listener);/*** 通知监听器*/void notifyListener();}编写测试的事件源：MySourcepublic class MySource implements EventSource {private List<EventListener> listeners = new ArrayList<EventListener>();private int value;@Overridepublic void addListener(EventListener listener) {listeners.add(listener);}@Overridepublic void notifyListener() {for (EventListener listener : listeners) {MyEvent event = new MyEvent();event.setSource(this);event.setWhen(new Date());event.setMessage("setValue " + value);listener.handleEvent(event);}}public int getValue() {return value;}public void setValue(int value) {this.value = value;notifyListener();}@Testpublic void testEventListener() {MySource source = new MySource();source.addListener(new MyListener());source.setValue(100);}}测试输出：[INFO]-[Event-callback(50)]: source: com.lichmama.test.listen.MySource@119126ab, message: setValue 100, when: 2018-05-01 02:52:13*PS：监听器模式和观察者模式看起来很像，不过在事件模型的设置上有些许差别。

java事件处理机制的基本原理
Java事件处理机制是基于事件监听器（EventListener）和事件
源（EventSource）的机制。

事件源是触发事件的对象，例如按钮、窗口等。

当事件源上发生某个事件时，事件源会创建一个对应的事件对象，并将该事件对象传递给监听器。

事件监听器是处理特定事件的对象，它实现了对应事件监听器接口。

例如，按钮点击事件的监听器需要实现ActionListener
接口。

当事件源触发事件时，它会将该事件对象传递给所有注册了监听器的对象，监听器会根据事件对象中的信息执行相应的操作。

基本原理如下：
1. 事件源注册监听器：事件源通过调用addXXXListener()方法，将监听器注册到事件源上。

2. 事件源触发事件：当事件源上发生了特定事件（例如按钮被点击），它会创建一个对应的事件对象，并将该事件对象传递给所有注册了监听器的对象。

3. 监听器接收事件：注册了监听器的对象会收到事件对象，并根据事件对象中的信息执行相应的操作。

4. 事件处理：监听器根据事件对象中的信息，执行一系列操作来处理事件。

事件处理机制的优点是低耦合性和可扩展性。

事件源和监听器
是通过接口进行交互，使得它们之间没有强制的依赖关系，从而实现了低耦合性。

同时，事件监听器机制支持多个监听器同时监听同一个事件源，可以方便地扩展和修改事件的处理方式。

详谈Java中的事件监听机制⿏标事件监听机制的三个⽅⾯：1.事件源对象：事件源对象就是能够产⽣动作的对象。

在Java语⾔中所有的容器组件和元素组件都是事件监听中的事件源对象。

Java中根据事件的动作来区分不同的事件源对象，动作发⽣在哪个组件上，那么该组件就是事件源对象2.事件监听⽅法：addMouseListener(MouseListener ml) ;该⽅法主要⽤来捕获⿏标的释放，按下，点击，进⼊和离开的动作；捕获到相应的动作后，交由事件处理类（实现MouseListener接⼝）进⾏处理。

addActionListener(ActionListener al);捕获类似按钮组件上的⿏标点击动作或者是类似输⼊框组件上的键盘回车动作；然后将动作以及相关信息交由事件处理类（实现ActionListener接⼝）的相应⽅法进⾏处理。

addMouseMotionListener(MouseMotionListener mml);捕获⿏标的移动和拖动动作；然后将动作以及相关信息交由事件处理类（实现MouseMotionListener 接⼝）的相应⽅法进⾏处理。

addKeyListener(KeyListener kl);捕获事件源对象上的键盘按键的按下、释放和敲击动作；然后将动作以及相关信息交由事件处理类（实现KeyListener 接⼝）的相应⽅法进⾏处理。

3.事件接⼝（事件处理类，也即实现了事件接⼝的类）：MouseListener ⿏标事件接⼝，有按下，释放，点击，进⼊和离开的事件处理⽅法ActionListener 动作事件接⼝，有动作对应的事件处理⽅法MouseMotionListener　⿏标移动事件接⼝，有移动和拖动的事件处理⽅法KeyLisetener 键盘事件接⼝，有释放，按下和敲击的事件处理⽅法了解了事件监听的这三个⽅⾯之后，我们要对组件添加事件的监听就很容易了。

下⾯是⼀个⼩例⼦：⽬标：创建⼀个简易的绘图板，可以实现按下相应的功能来达到不同的绘画⽬的。

JAVA事件处理机制JAVA事件处理机制是指在JAVA编程中对事件进行监听和响应的一种机制。

在JAVA中，事件是指用户在程序运行过程中进行的各种操作，如鼠标点击、键盘输入、窗口关闭等。

通过事件处理机制，程序可以在特定事件发生时触发相应的操作，从而实现与用户的交互。

在JAVA中，事件处理机制主要涉及到以下几个方面：事件源、事件监听器、事件对象和事件处理器。

事件源是指能够触发事件的对象，例如按钮、文本框等；事件监听器是指用来监听事件的对象，它实现了相应的事件监听接口；事件对象是指封装了事件源和事件信息的对象，它包含了发生事件的相关属性；事件处理器是指在事件被触发时需要执行的操作，可以通过事件监听器来定义。

事件处理机制通常包括以下几个步骤：1.创建事件源对象：例如创建一个按钮对象。

2.创建事件监听器对象：实现相应的事件监听接口，并重写事件处理方法。

3.将事件监听器对象注册到事件源对象中：通过调用事件源对象的方法将事件监听器对象注册到事件源对象中，使其能够监听事件源对象的事件。

4.触发事件：用户进行相应操作后，事件源对象会触发相应的事件。

5.事件源对象通知事件监听器对象：事件源对象会调用事件监听器对象的相应方法，将事件对象作为参数传递给事件监听器对象。

6.事件监听器对象执行操作：事件监听器对象接收到事件对象后，根据事件对象中的信息执行相应的操作。

通过事件处理机制，可以实现丰富的用户交互功能。

例如，在一个图形界面程序中，用户点击按钮时，可以触发按钮的点击事件，然后执行相应的操作，如弹出对话框、刷新界面等。

又如，用户在文本框中输入内容时，可以触发文本框的输入事件，然后进行相应的校验、处理等操作。

JAVA提供了丰富的事件监听接口和类库，使得事件处理变得更加方便。

例如，对于鼠标事件，可以使用MouseListener接口和MouseAdapter适配器类来实现对鼠标事件的监听和处理。

对于键盘事件，可以使用KeyListener接口和KeyAdapter适配器类来实现对键盘事件的监听和处理。

在Java 中，事件处理是通过事件监听器（Event Listeners）和事件对象（Event Objects）来实现的。

以下是一些常见的Java 事件处理方法：1. 基于接口的事件处理：使用接口定义事件监听器，然后实现该接口的类成为事件监听器类。

在事件源上注册监听器，当事件发生时，触发监听器中的方法。

// 事件监听器接口public interface MyEventListener {void onEventOccurred(MyEvent event);}// 事件对象public class MyEvent {// 事件相关信息}// 事件源public class MyEventSource {private List<MyEventListener> listeners = new ArrayList<>();public void addEventListener(MyEventListener listener) {listeners.add(listener);}public void fireEvent(MyEvent event) {for (MyEventListener listener : listeners) {listener.onEventOccurred(event);}}}// 使用示例public class EventHandlingExample implements MyEventListener {public static void main(String[] args) {MyEventSource eventSource = new MyEventSource();EventHandlingExample eventHandler = new EventHandlingExample();eventSource.addEventListener(eventHandler);// 模拟事件发生MyEvent event = new MyEvent();eventSource.fireEvent(event);}@Overridepublic void onEventOccurred(MyEvent event) {// 处理事件的逻辑System.out.println("Event occurred!");}}2. 匿名内部类实现事件监听器：可以使用匿名内部类实现事件监听器接口，避免创建额外的类。

java监听事件原理Java 监听事件是一种常见的编程模式，用于在特定事件发生时执行相应的操作。

它可以帮助我们实现程序的交互性和实时响应能力。

本文将从原理层面介绍Java监听事件的实现方式和工作原理。

我们需要了解什么是事件。

在计算机领域，事件指的是程序运行过程中发生的某种特定的动作或状态变化。

例如，鼠标点击、键盘按下、窗口关闭等都是事件的例子。

在Java中，事件一般通过监听器（Listener）来进行处理。

Java监听事件的原理是基于观察者设计模式。

观察者设计模式是一种对象之间的一对多依赖关系，当一个对象的状态发生改变时，其所有依赖它的对象都会得到通知并自动更新。

在Java中，观察者模式的实现方式是通过事件源（Event Source）和事件监听器（Event Listener）两个角色来完成的。

事件源是产生事件的对象，它会在特定事件发生时通知事件监听器。

事件监听器则是负责监听事件源，并在事件发生时执行相应的操作。

事件源和事件监听器之间通过注册和回调机制建立联系。

具体来说，事件监听器需要实现一个特定的监听器接口，该接口定义了需要监听的事件类型和相应的处理方法。

事件源则需要提供注册监听器和触发事件的方法。

在Java中，常见的事件监听器接口包括ActionListener、MouseListener、KeyListener等。

这些接口定义了不同类型的事件和相应的处理方法。

例如，ActionListener用于处理按钮点击事件，MouseListener用于处理鼠标点击事件，KeyListener用于处理键盘按下事件等。

要实现Java监听事件，我们需要以下几个步骤：1. 创建事件源对象：即产生事件的对象，例如按钮、窗口等。

2. 创建事件监听器对象：即用于监听特定事件的对象，它需要实现相应的监听器接口。

3. 注册事件监听器：将事件监听器对象注册到事件源对象上，使其能够监听特定事件的发生。

4. 触发事件：当特定事件发生时，事件源对象会调用相应的回调方法，通知所有注册的事件监听器对象。

JAVA中按钮的事件监听的三种⽅式JAVA中的Swing组件，按钮的重点是进⾏事件的监听，可以通过调⽤JButton的addActionListener()⽅法。

这个⽅法接受⼀个实现ActionListener接⼝的对象作为参数，ActionListener接⼝中只包含⼀个actionPerformed()⽅法，所以如果想把事件处理的代码与JButton进⾏关联，就需要如下的三种做法：第⼀种：public class Button extends MyFrame {private JButtonb1 = new JButton("Button1"),b2 = new JButton("Button2");private JTextField txt = new JTextField(10);class ButtonListener implements ActionListener{// 定义内部类实现事件监听public void actionPerformed(ActionEvent e) {txt.setText(((JButton)e.getSource()).getText()) ;/** String name = ((JButton)e.getSource()).getText();* txt.setText(name);*/}}private ButtonListener b = new ButtonListener();public Button(){b1.addActionListener(b);b2.addActionListener(b);this.setLayout(new FlowLayout());this.add(b1);this.add(b2);this.add(txt);}public static void main(String[] args) {SwingUtilities.invokeLater(new Runnable() {public void run() {new Button();}});}}第⼆种：//直接创建ActionListener的类的对象b，使⽤的是匿名内部类private ActionListener b= new ActionListener(){// 定义内部类实现事件监听public void actionPerformed(ActionEvent e) {txt.setText(((JButton)e.getSource()).getText()) ;/** String name = ((JButton)e.getSource()).getText();* txt.setText(name);*/}};第三种：//在程序中直接创建按钮的监听，不需要再引⼊监听器b1.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e) {txt.setText(((JButton)e.getSource()).getText());}});b2.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e) {txt.setText(" "); }});。

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();}//实现事件监听器接口class ExitHandler implements ActionListener,WindowListener{//重写其中的抽象方法public void actionPerformed(ActionEvent e) {if(e.getSource()==mExit){System.exit(0);}else if(e.getSource()==mi1){System.out.println("新建按钮被按下");}else if(e.getSource()==mi2){System.out.println("打开按钮被按下");}}public void windowActivated(WindowEvent arg0) {//激活窗口 P190}public void windowClosed(WindowEvent arg0) {//窗口关闭时}public void windowClosing(WindowEvent arg0) {//退出窗口System.exit(0);}public void windowDeactivated(WindowEvent arg0) { //窗口非激活时}public void windowDeiconified(WindowEvent arg0) { //窗口非图标化时}public void windowIconified(WindowEvent arg0) {//窗口图标化时}public void windowOpened(WindowEvent arg0) {//窗口打开时}}}【练习】两个窗体，每个窗体上各有一个按钮，当点击此按钮时显示另外一个窗体public class FrameChangeDemo {public int n = 1;Frame1 f1;Frame2 f2;public FrameChangeDemo(){f1 = new Frame1();f2 = new Frame2();}public static void main(String[] args) {FrameChangeDemo fcd = new FrameChangeDemo();}class Frame1 extends Frame{Button btn;public Frame1(){this.setBounds(0,0,400,300);btn = new Button("显示窗体2");btn.setBackground(Color.red);btn.addActionListener(new BtnHandle());this.add(btn);this.setTitle("窗体1");this.setVisible(true);}}class Frame2 extends Frame{Button btn;public Frame2(){this.setBounds(0,0,400,300);btn = new Button("显示窗体1");btn.setBackground(Color.green);btn.addActionListener(new BtnHandle());this.add(btn);this.setTitle("窗体2");this.setVisible(false);}}class BtnHandle implements ActionListener{public void actionPerformed(ActionEvent e) { if(n==1){f1.setVisible(false);f2.setVisible(true);n=2;}else if(n==2){f1.setVisible(true);f2.setVisible(false);n=1;}}}}。