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实现一个简单的事件监听器
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事件处理机制的基本原理
Java事件处理机制是基于事件监听器（EventListener）和事件
源（EventSource）的机制。
事件源是触发事件的对象，例如按钮、窗口等。
当事件源上发生某个事件时，事件源会创建一个对应的事件对象，并将该事件对象传递给监听器。
事件监听器是处理特定事件的对象，它实现了对应事件监听器接口。
例如，按钮点击事件的监听器需要实现ActionListener
接口。
当事件源触发事件时，它会将该事件对象传递给所有注册了监听器的对象，监听器会根据事件对象中的信息执行相应的操作。
基本原理如下：
1. 事件源注册监听器：事件源通过调用addXXXListener()方法，将监听器注册到事件源上。
2. 事件源触发事件：当事件源上发生了特定事件（例如按钮被点击），它会创建一个对应的事件对象，并将该事件对象传递给所有注册了监听器的对象。
3. 监听器接收事件：注册了监听器的对象会收到事件对象，并根据事件对象中的信息执行相应的操作。
4. 事件处理：监听器根据事件对象中的信息，执行一系列操作来处理事件。
事件处理机制的优点是低耦合性和可扩展性。
事件源和监听器
是通过接口进行交互，使得它们之间没有强制的依赖关系，从而实现了低耦合性。
同时，事件监听器机制支持多个监听器同时监听同一个事件源，可以方便地扩展和修改事件的处理方式。
详谈Java中的事件监听机制
详谈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中，事件是指用户在程序运行过程中进行的各种操作，如鼠标点击、键盘输入、窗口关闭等。
通过事件处理机制，程序可以在特定事件发生时触发相应的操作，从而实现与用户的交互。
在JAVA中，事件处理机制主要涉及到以下几个方面：事件源、事件监听器、事件对象和事件处理器。
事件源是指能够触发事件的对象，例如按钮、文本框等；事件监听器是指用来监听事件的对象，它实现了相应的事件监听接口；事件对象是指封装了事件源和事件信息的对象，它包含了发生事件的相关属性；事件处理器是指在事件被触发时需要执行的操作，可以通过事件监听器来定义。
事件处理机制通常包括以下几个步骤：1.创建事件源对象：例如创建一个按钮对象。
2.创建事件监听器对象：实现相应的事件监听接口，并重写事件处理方法。
3.将事件监听器对象注册到事件源对象中：通过调用事件源对象的方法将事件监听器对象注册到事件源对象中，使其能够监听事件源对象的事件。
4.触发事件：用户进行相应操作后，事件源对象会触发相应的事件。
5.事件源对象通知事件监听器对象：事件源对象会调用事件监听器对象的相应方法，将事件对象作为参数传递给事件监听器对象。
6.事件监听器对象执行操作：事件监听器对象接收到事件对象后，根据事件对象中的信息执行相应的操作。
通过事件处理机制，可以实现丰富的用户交互功能。
例如，在一个图形界面程序中，用户点击按钮时，可以触发按钮的点击事件，然后执行相应的操作，如弹出对话框、刷新界面等。
又如，用户在文本框中输入内容时，可以触发文本框的输入事件，然后进行相应的校验、处理等操作。
JAVA提供了丰富的事件监听接口和类库，使得事件处理变得更加方便。
例如，对于鼠标事件，可以使用MouseListener接口和MouseAdapter适配器类来实现对鼠标事件的监听和处理。
对于键盘事件，可以使用KeyListener接口和KeyAdapter适配器类来实现对键盘事件的监听和处理。
java语言中的事件处理方法
在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监听事件的实现方式和工作原理。
我们需要了解什么是事件。
在计算机领域，事件指的是程序运行过程中发生的某种特定的动作或状态变化。
例如，鼠标点击、键盘按下、窗口关闭等都是事件的例子。
在Java中，事件一般通过监听器（Listener）来进行处理。
Java监听事件的原理是基于观察者设计模式。
观察者设计模式是一种对象之间的一对多依赖关系，当一个对象的状态发生改变时，其所有依赖它的对象都会得到通知并自动更新。
在Java中，观察者模式的实现方式是通过事件源（Event Source）和事件监听器（Event Listener）两个角色来完成的。
事件源是产生事件的对象，它会在特定事件发生时通知事件监听器。
事件监听器则是负责监听事件源，并在事件发生时执行相应的操作。
事件源和事件监听器之间通过注册和回调机制建立联系。
具体来说，事件监听器需要实现一个特定的监听器接口，该接口定义了需要监听的事件类型和相应的处理方法。
事件源则需要提供注册监听器和触发事件的方法。
在Java中，常见的事件监听器接口包括ActionListener、MouseListener、KeyListener等。
这些接口定义了不同类型的事件和相应的处理方法。
例如，ActionListener用于处理按钮点击事件，MouseListener用于处理鼠标点击事件，KeyListener用于处理键盘按下事件等。
要实现Java监听事件，我们需要以下几个步骤：1. 创建事件源对象：即产生事件的对象，例如按钮、窗口等。
2. 创建事件监听器对象：即用于监听特定事件的对象，它需要实现相应的监听器接口。
3. 注册事件监听器：将事件监听器对象注册到事件源对象上，使其能够监听特定事件的发生。
4. 触发事件：当特定事件发生时，事件源对象会调用相应的回调方法，通知所有注册的事件监听器对象。
JAVA中按钮的事件监听的三种方式
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事件监听机制
开始之前首先问个问题：您熟悉java.util.EventObject和java.util.EventListener两个类以及他们已有的子类吗？
{
public void demoEvent(DemoEvent de)
{
System.out.println("Inside listener1...");
}
}
Listener2.java
package demo.listener;
public class Listener2 implements DemoListener
{
}
public void addDemoListener(DemoListener dl)
{
repository.addElement(dl);
}
public void notifyDemoEvent()
{
Enumeration enum = repository.elements();
while(enum.hasMoreElements())
DemoEvent.java
package demo.listener;
import java.util.EventObject;
public class DemoEvent extends EventObject
{
Object obj;
Java的事件处理机制
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;}}}}。
监听器的四种监听方法
30.c.setBackground(Color.red);
31.}
32.}
33./**************************************/
34.
35.publicstaticvoidmain(String args[]){
41.c.setBackground(Color.red);
42.}
43.}
匿名内部类作为事件监听器:
Java代码
1.importjava.awt.*;
2.importjava.awt.event.*;
3.importjavax.swing.*;
4.
5./**
6.*Java事件处理机制:匿名内部类作为事件监听器
16.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
17.
18.btn=newJButton("点击");
19.btn.addActionListener(newInnerClass());
20.getContentPane().add(btn);
21.
23.setVisible(true);
24.}
25.
26./**************************************/
27.publicvoidactionPerformed (ActionEvent e){
28.Container c=getContentPane();
29.c.setBackground(Color.red);
8.*@version2008-12-3
java事件监听处理代码
java事件监听处理代码在Java中，事件监听是一种常见的编程技巧，用于捕获和处理用户交互事件。
通过事件监听，我们可以实现用户在程序界面上的各种操作与相应的响应逻辑之间的联系。
本文将介绍Java事件监听处理代码的示例和实现细节。
一、事件监听的基本概念在Java中，事件监听机制是基于观察者模式实现的。
事件源（Event Source）是指能够触发事件的对象，而事件监听器（Event Listener）则是对事件进行监听并作出响应的对象。
当事件源触发某个事件时，系统会自动调用事件监听器中对应的方法，从而实现事件的处理。
二、创建事件监听器首先，我们需要创建一个事件监听器类，该类实现了特定的事件监听接口，并重写了对应的事件处理方法。
以按钮点击事件为例，创建一个ButtonClickListener事件监听器类：```import java.awt.event.ActionEvent;import java.awt.event.ActionListener;public class ButtonClickListener implements ActionListener {@Overridepublic void actionPerformed(ActionEvent e) {// 在这里编写相应的事件处理逻辑}}```在上述代码中，实现了ActionListener接口，并重写了actionPerformed()方法。
在该方法中，我们可以编写具体的事件处理逻辑。
三、注册事件监听器接下来，我们需要将事件监听器注册到事件源上，以便在事件触发时执行对应的处理代码。
在Java中，常见的事件源包括按钮、菜单、文本框等。
以按钮为例，注册按钮点击事件监听器的代码如下：```import javax.swing.JButton;public class Main {public static void main(String[] args) {JButton button = new JButton("Click Me");ButtonClickListener listener = new ButtonClickListener();button.addActionListener(listener);}}```在上述代码中，我们首先创建了一个按钮实例button，然后创建了一个ButtonClickListener事件监听器的实例listener。
java监听器实现原理
java监听器实现原理Java监听器实现原理在Java应用程序中，事件机制的实现是非常重要的一部分，用来处理应用程序的各种事件，例如监听窗口尺寸、鼠标单击等等。
Java中提供了许多类来实现这个目的，其中一种类就是监听器（Listener）。
本文将介绍Java监听器实现原理，并结合实例进行详细讲解。
1、什么是Java监听器？Java监听器是一种事件回调机制，用于处理事件驱动的机制。
Java监听器使得可以将事件的逻辑处理代码作为方法放置于监听器接口中，当事件被触发时，监听器接口的方法就会被调用。
主要作用在于对某些程序对象的变化或者状态进行监听，以便于程序对这些变化或者状态进行响应和处理。
2、Java监听器的实现步骤2.1、定义监听器接口Java监听器实现首先要定义一个监听器接口，接口名通常以Listener结尾，其中定义了事件处理方法。
例如，在Java程序中定义一个用于监听按钮事件的ButtonListener接口：```public interface ButtonListener {public void buttonClicked(ButtonEvent e);}```2.2、定义事件类在Java程序中，通常使用事件对象来传递事件信息，因此需要定义事件类。
事件类包含了监听器接口对象，以便于在事件发生时调用接口方法。
例如，在Java程序中定义一个事件类ButtonEvent：```public class ButtonEvent {private Button source;public ButtonEvent(Button source) {this.source = source;}public Button getSource() {return source;}}```2.3、定义事件源事件源类是触发事件的对象，通常是一个控件或一个对象。
事件源类包含了对监听器接口的引用，以便于在事件发生时通知监听器。
java的事件处理机制
java的事件处理机制
Java的事件处理机制是一种用于处理用户与界面元素交互的方法。
当用户执行某些操作（如点击按钮、按下键盘或移动鼠标等）时，Java将触发一个相应的事件，然后系统将调用相应的事件处理程序来响应该事件。
Java的事件处理机制包括以下几个步骤：
1. 创建事件对象：当某个事件发生时，Java会创建一个对应的事件对象，该对象包含了事件的详细信息，如事件的类型、发生的时间和发生的位置等。
2. 注册事件监听器：事件监听器是用于监听特定事件的类。
当某个事件发生时，系统将自动调用该事件监听器的相应方法来处理该事件。
开发者需要在代码中注册事件监听器，以便在事件发生时能够处理它。
3. 事件分发：当某个事件发生时，系统将该事件对象分发给相应的事件监听器。
事件监听器将根据事件对象的类型和信息来决定如何处理该事件。
4. 事件处理：事件监听器将调用相应的方法来处理事件。
该方法通常在事件监听器类中定义，并实现了特定的事件处理逻辑。
5. 更新界面：在事件处理完成后，系统可能会更新界面以反映事件的结果。
例如，当用户点击一个按钮时，系统可能会显示一个对话框或更新一个文本框的内容。
Java的事件处理机制提供了灵活和可扩展的方式来处理用户与界面元素的交互。
通过使用事件监听器和事件处理程序，开发者可以轻松地编写出响应用户操作的代码，从而实现更加丰富的交互功能。
常用事件及对应监听器和方法
常用事件及对应监听器和方法在Java中，事件是指在程序运行过程中发生的用户操作或其他活动，比如鼠标点击、键盘输入、窗口关闭等。
为了响应这些事件，通常需要使用特定的监听器和方法。
以下是一些常用的事件及相应的监听器和方法：1.鼠标点击事件：监听器：MouseListener方法：- mouseClicked(MouseEvent e): 鼠标按钮在组件上按下并释放时调用- mousePressed(MouseEvent e): 鼠标按钮在组件上按下时调用- mouseReleased(MouseEvent e): 鼠标按钮在组件上释放时调用- mouseEntered(MouseEvent e): 鼠标进入组件时调用- mouseExited(MouseEvent e): 鼠标离开组件时调用2.键盘事件：监听器：KeyListener方法：- keyPressed(KeyEvent e): 键盘按键按下时调用- keyReleased(KeyEvent e): 键盘按键释放时调用- keyTyped(KeyEvent e): 键盘按键被打印时调用3.窗口关闭事件：监听器：WindowListener方法：- windowClosing(WindowEvent e): 窗口将要关闭时调用- windowClosed(WindowEvent e): 窗口已经关闭时调用- windowOpened(WindowEvent e): 窗口第一次被打开时调用- windowIconified(WindowEvent e): 窗口从正常状态最小化时调用- windowDeiconified(WindowEvent e): 窗口从最小化状态恢复正常时调用- windowActivated(WindowEvent e): 窗口被激活时调用- windowDeactivated(WindowEvent e): 窗口失去焦点时调用4.按钮点击事件：监听器：ActionListener方法：- actionPerformed(ActionEvent e): 当按钮被点击时调用5.列表选择事件：监听器：ListSelectionListener方法：- valueChanged(ListSelectionEvent e): 当列表中的选择项发生变化时调用6.文本框输入事件：监听器：DocumentListener方法：- insertUpdate(DocumentEvent e): 当文本框中有文本插入时调用- removeUpdate(DocumentEvent e): 当文本框中有文本删除时调用- changedUpdate(DocumentEvent e): 当文本框的属性发生变化时调用7.鼠标移动事件：监听器：MouseMotionListener方法：- mouseDragged(MouseEvent e): 鼠标拖动时调用- mouseMoved(MouseEvent e): 鼠标移动时调用8.下拉菜单选择事件：监听器：ItemListener方法：- itemStateChanged(ItemEvent e): 当下拉菜单项的选择状态发生变化时调用以上仅仅列举了一些常用的事件及相应的监听器和方法，实际上还有很多其他类型的事件和对应的监听器和方法。
java中的四种监听类用法
java中的四种监听类⽤法在此列举四种⽅法：1. ⾃⾝类实现ActionListener接⼝，作为事件监听器2. 通过匿名类处理3. 通过内部类处理4. 通过外部类处理下⾯依次介绍：第⼀种：⾃⾝类实现ActionListener接⼝，作为事件监听器。
这种⽅法是最基本的，也是初学者经常使⽤的，我当初即是如此。
import java.awt.Color;import java.awt.Container;import java.awt.FlowLayout;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.JButton;import javax.swing.JDialog;import javax.swing.JFrame;public class EventListener1 extends JFrame implements ActionListener {private JButton btBlue, btDialog;// 构造⽅法public EventListener1() {// 设置标题栏内容setTitle("Java GUI 事件监听处理");// 设置初始化窗⼝位置setBounds(100, 100, 500, 350);// 设置窗⼝布局setLayout(new FlowLayout());// 创建按钮对象btBlue = new JButton("蓝⾊");// 将按钮添加事件监听器btBlue.addActionListener(this);// 创建按钮对象btDialog = new JButton("弹窗");// 将按钮添加事件监听器btDialog.addActionListener(this);// 把按钮容器添加到JFrame容器上add(btBlue);add(btDialog);// 设置窗⼝可视化setVisible(true);// 设置窗⼝关闭setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}// ***************************事件处理***************************@Overridepublic void actionPerformed(ActionEvent e) {// 判断最初发⽣Event事件的对象if (e.getSource() == btBlue) {// 获得容器Container c = getContentPane();// 设置容器背景颜⾊c.setBackground(Color.BLUE);}else if (e.getSource() == btDialog) {// 创建JDialog窗⼝对象JDialog dialog = new JDialog();dialog.setBounds(300, 200, 400, 300);dialog.setVisible(true);}}// ***************************主⽅法***************************public static void main(String[] args) {new EventListener1();}}第⼆种，通过匿名类处理。
如何实现Java监听器详解
如何实现Java监听器详解⽬录⼀、前⾔⼆、监听器模型三、案例实现四、测试⼀、前⾔监听器就是监听事件源是否发⽣了某⼀个事件，当发⽣指定监听的事件时事件源会向已注册的监听器发送消息对象。
监听器可以获得事件对象进⾏相关操作。
⼆、监听器模型事件源：发⽣事件的对象消息：触发监听的某⼀个事件监听器：监听发⽣的某个事件进⾏业务处理三、案例实现在开发者进⾏开发和学习之前进⾏监听处理业务逻辑。
DeveloperListenerpackage demo.listener;/*** 监听器接⼝* dingwen* 2021/5/30 14:35**/public interface DeveloperListener {/*** ⼯作** @param event 事件*/void work(Event event);/*** 研究** @param event 事件*/void study(Event event);}Developerpackage demo.listener;import java.util.Optional;import java.util.function.Supplier;/*** 开发者类* dingwen* 2021/5/30 14:34**/public class Developer {private DeveloperListener developerListener;/*** 注册监听器** @param developerListener 开发⼈员监听器*/public void registerListener(DeveloperListener developerListener) {this.developerListener = developerListener;}/*** ⼯作*/public void work() {if (developerListener != null) {this.developerListener.work(new Event(this));}System.out.println("developer work");}/*** 研究*/public void study(){if (developerListener != null){this.developerListener.study(new Event(this));System.out.println("developer study");}}}Eventpackage demo.listener;/*** 事件对象* dingwen* 2021/5/30 14:32**/public class Event {/*** 开发⼈员*/private Developer developer;public Event(Developer developer) {this.developer = developer;}public Event() {}public Developer getDeveloper() {return developer;}public void setDeveloper(Developer developer) {this.developer = developer;}}DeveloperListenerImplpackage demo.listener;/*** developer listener impl* dingwen* 2021/5/30 14:38**/public class DeveloperListenerImpl implements DeveloperListener {@Overridepublic void work(Event event) {Developer developer = event.getDeveloper();System.out.println("work developer impl listener");}@Overridepublic void study(Event event) {Developer developer = event.getDeveloper();System.out.println("study developer impl listener");}}四、测试package demo.listener;/*** 测试* dingwen* 2021/5/30 14:57**/public class ListenerTest {public static void main(String[] args) {Developer developer = new Developer();developer.registerListener(new DeveloperListenerImpl());developer.study();developer.work();}}到此这篇关于如何实现Java监听器详解的⽂章就介绍到这了,更多相关Java监听器内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。
监听事件实现的四种方法
监听事件实现的四种⽅法1.初始化当前所需要控件，如何初始化⼀个控件…………private Button xxxxfindViewById---返回的是⼀个View的对象…………需要强转成其⼦类Button对象findViewById---是如何查找View的Id…………通过R中的ID2.设置Button的监听器，通过监听器实现我们点击Button需要操作的事情⽅式⼀：匿名内部类实现事件监听：在按钮的setOnClickListener⽅法中new⼀个OnClickListener类，并在OnClickListener类的实现中写出需要实现的代码，如：Button loninButton = (Button) findViewId(R.id.bt1);loginButton.setOnClickListener(new OnClickListener(){实现的内容}）;⽅式⼆：外部类监听事件：有多个按钮，每个按钮都有⼀个相同的动作，另外每个按钮有⼀个⾃⼰的动作，这样的情况使⽤外部类监听事件。
添加⼀个实现OnClickListener接⼝的MyOnClickListener类重写onClick();⽅法，在⽅法体内添加需要重复实现的动作；然后在每⼀个接⼝下⾯实现各⾃独⽴的动作，如：bt2.setOnClickListener(new MyOnClickListener(){public void onClick(View v) {super.onClick(v);//实现⽗类的onClick();动作Toast.makeText(MainActivity.this, "BT3要执⾏的逻辑", Toast.LENGTH_SHORT).show();} });⽅式三：接⼝⽅式实现事件监听：activityMain类实现OnClickListener接⼝，然后重写OnClickListener接⼝的onClick();⽅法，在调⽤的时候，直接写this就可以了，如：imgBt.setOnClickListener(this);⽅式四：独⽴事件loginButton.setOnClickListener(listener);外部单独：OnClickListener listener = new OnClickListener() {@Overridepublic void onClick(View v) {// TODO Auto-generated method stubSystem.out.println("独⽴实现的类触发了");}};。
java事件
java事件JAVA事件机制事件机制包含3个部分：事件，监听器，事件源1.事件继承java.util.EventObject类，封装了事件源对象及跟踪事件相关信息⾃定义事件类CustomEventimport java.util.EventObject;public class CustomEvent extends EventObject {/*** Constructs a prototypical Event.** @param source The object on which the Event initially occurred.* @throws IllegalArgumentException if source is null.*/public CustomEvent(Object source) {super(source);}}2.事件监听器实现java.util.EventListener接⼝，核⼼是：事件监听器要注册到事件源（事件对象⾥内嵌的object）上，当事件源属性或者状态修改，遍历监听器并调⽤监听器其内部回调⽅法。
⾃定义事件监听器CustomEventListenerimport java.util.EventListener;// 事件监听器，定义回调⽅法，将要做的事放到这个⽅法下，事件源发⽣相应的事件会调⽤这个⽅法public class CustomEventListener implements EventListener {// 处理事件的⽅法public void fireEvent(CustomEvent event){Object obj = event.getSource();System.out.println("deal event : " + obj.toString());}}3.事件源最核⼼的地⽅，事件发⽣的地⽅由于事件源的某个属性发⽣了改变，⽣成了相应的时间对象，事件监听器⼀定要注册到事件源上，事件源中要有装监听器的容器EventSourceObjectpublic class EventSourceObject {private String name;// 监听器容器private Set<CustomEventListener> listeners;public EventSourceObject() {this.listeners = Sets.newHashSet(); = "defaultName";}// 给时间源注册监听器public void addCustomListener(CustomEventListener listener){this.listeners.add(listener);}// 当事件发⽣时，通知注册在该事件源上的所有监听器做出相应反应protected void noties(){this.listeners.parallelStream().forEach(listener -> {listener.fireEvent(new CustomEvent(this));});}public String getName(){return name;}public void setName(String name){if (!.equalsIgnoreCase(name)){ = name;noties();}}}4.主⽅法public class MainTest {public static void main(String[] args) {EventSourceObject eventSourceObject = new EventSourceObject(); eventSourceObject.addCustomListener(new CustomEventListener()); eventSourceObject.setName("3");}}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Java事件处理机制- 事件监听器的四种实现方式自身类作为事件监听器外部类作为事件监听器匿名内部类作为事件监听器内部类作为事件监听器自身类作为事件监听器:Java代码复制代码收藏代码import javax.swing.*;import java.awt.*;import java.awt.event.*;/***Java事件处理机制:自身类作为事件监听器*@author Winty(wintys@)*@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[]){new ThisClassEvent();}}import javax.swing.*;import java.awt.*;import java.awt.event.*;/***Java事件处理机制:自身类作为事件监听器*@author Winty(wintys@)*@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[]){new ThisClassEvent();}}外部类作为事件监听器:Java代码复制代码收藏代码import java.awt.*;import java.awt.event.*;import javax.swing.*;/***Java事件处理机制:外部类作为事件监听器*@author Winty(wintys@)*@version 2008-12-3*/class OuterClassEvent extends JFrame{JButton btn;public OuterClassEvent(){super("Java事件监听机制");setLayout(new FlowLayout());setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);btn=new JButton("点击");btn.addActionListener(new OuterClass(this));getContentPane().add(btn);setBounds(200,200,300,160);setVisible(true);}public static void main(String args[]){new OuterClassEvent();}}/*外部类*********************************/class OuterClass implements ActionListener{OuterClassEvent oce;public OuterClass(OuterClassEvent oce){this.oce = oce;}public void actionPerformed(ActionEvent e){Container c=oce.getContentPane();c.setBackground(Color.red);}}import java.awt.*;import java.awt.event.*;import javax.swing.*;/***Java事件处理机制:外部类作为事件监听器*@author Winty(wintys@)*@version 2008-12-3*/class OuterClassEvent extends JFrame{JButton btn;public OuterClassEvent(){super("Java事件监听机制");setLayout(new FlowLayout());setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);btn=new JButton("点击");btn.addActionListener(new OuterClass(this));getContentPane().add(btn);setBounds(200,200,300,160);setVisible(true);}public static void main(String args[]){new OuterClassEvent();}}/*外部类*********************************/class OuterClass implements ActionListener{OuterClassEvent oce;public OuterClass(OuterClassEvent oce){this.oce = oce;}public void actionPerformed(ActionEvent e){Container c=oce.getContentPane();c.setBackground(Color.red);}}匿名内部类作为事件监听器:Java代码复制代码收藏代码import java.awt.*;import java.awt.event.*;import javax.swing.*;/***Java事件处理机制:匿名内部类作为事件监听器*@author Winty(wintys@)*@version 2008-12-3*/class AnonymousEvent extends JFrame{JButton btn;public AnonymousEvent(){super("Java事件监听机制");setLayout(new FlowLayout());setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);btn=new JButton("点击");/*匿名内部类******************************/btn.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e){Container c=getContentPane();c.setBackground(Color.red);}});/***************************************/getContentPane().add(btn);setBounds(200,200,300,160);setVisible(true);}public static void main(String args[]){new AnonymousEvent();}}import java.awt.*;import java.awt.event.*;import javax.swing.*;/***Java事件处理机制:匿名内部类作为事件监听器*@author Winty(wintys@)*@version 2008-12-3*/class AnonymousEvent extends JFrame{JButton btn;public AnonymousEvent(){super("Java事件监听机制");setLayout(new FlowLayout());setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);btn=new JButton("点击");/*匿名内部类******************************/btn.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e){Container c=getContentPane();c.setBackground(Color.red);}});/***************************************/getContentPane().add(btn);setBounds(200,200,300,160);setVisible(true);}public static void main(String args[]){new AnonymousEvent();}}内部类作为事件监听器:Java代码复制代码收藏代码import java.awt.*;import java.awt.event.*;import javax.swing.*;/***Java事件处理机制:内部类作为事件监听器*@author Winty(wintys@)*@version 2008-12-3*/class InnerClassEvent extends JFrame{JButton btn;public InnerClassEvent(){super("Java事件监听机制");setLayout(new FlowLayout());setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);btn=new JButton("点击");btn.addActionListener(new InnerClass());getContentPane().add(btn);setBounds(200,200,300,160);setVisible(true);}/*内部类*********************************/class InnerClass implements ActionListener{public void actionPerformed (ActionEvent e){Container c=getContentPane();c.setBackground(Color.red);}}/**************************************/public static void main(String args[]){new InnerClassEvent();}}。