java事件监听

2021-05-26 16:00:14

在程序开发中，经常需要对某些事件进行监听，如监听鼠标点击事件、监听键盘按下事件等，此时就需要使用事件监听器，事件监听器用于对程序中发生的事件进行监听，在监听的过程中会涉及几个重要组成部分，具体如下：
● 事件(Event)：用户的一个操作，如点击一个按钮、调用一个方法、创建一个对象等。
● 事件源：产生事件的对象。
● 事件监听器(Listener)：负责监听发生在事件源上的事件。
● 事件处理器：监听器的成员方法，当事件发生的时候会触发对应的处理器(成员方法)。
当用户进行一个操作触发事件源上的事件时，就会被事件监听器监听到，当监听器监听到事件发生时，相应的事件处理器就会对发生的事件进行处理。
事件监听器在进行工作时，可分为几个步骤，具体如下：
(1)将监听器绑定到事件源，也就是注册监听器。
(2)事件发生时会触发监听器的成员方法，即事件处理器，传递事件对象。
(3)事件处理器通过事件对象获得事件源，并对事件源进行处理。
在开发Web应用程序时，也经常会使用事件监听器，这个事件监听器被称为Servlet事件监听器，Servlet事件监听器就是一个实现特定接口的Java程序，专门用于监听Web应用程序中ServletContext、HttpSession和ServletRequest等域对象的创建和销毁过程，监听这些域对象属性的修改以及感知绑定到HttpSession域中某个对象的状态。根据监听事件的不同可以将其分为三类，具体如下：
● 用于监听域对象创建和销毁的事件监听器(ServletContextListener接口、HttpSessionListener接口、ServletRequestListener接口)。
● 用于监听域对象属性增加和删除的事件监听器(ServletContextAttributeListener接口、HttpSessionAttributeListener接口、ServletRequestAttributeListener接口)。
● 用于监听绑定到HttpSession域中某个对象状态的事件监听器(HttpSessionBindingListener接口、HttpSessionActivationListener接口)。
在Servlet规范中，这三类事件监听器都定义了相应的接口，在编写事件监听器程序时只需实现对应的接口就可以。Web服务器会根据监听器所实现的接口，把它注册到被监听的对象上，当触发了某个对象的监听事件时，Web容器将会调用Servlet监听器与之相关的方法对事件进行处理。

更多相关内容
Java事件监听器的四种实现方式
千次阅读 2021-02-13 00:54:39

自身类作为事件监听器外部类作为事件监听器匿名内部类作为事件监听器内部类作为事件监听器自身类作为事件监听器:1 import javax.swing.*;2 import java.awt.*;3 import java.awt.event.*;45 /**6 *Java事件处理机制:...

自身类作为事件监听器

外部类作为事件监听器

匿名内部类作为事件监听器

内部类作为事件监听器

自身类作为事件监听器:

1 import javax.swing.*;2 import java.awt.*;3 import java.awt.event.*;4

5 /**

6 *Java事件处理机制:自身类作为事件监听器7 *@authorWinty(wintys@gmail.com)8 *@version2008-12-39 */

10 class ThisClassEvent extends JFrame implementsActionListener{11 JButton btn;12

13 publicThisClassEvent(){14 super("Java事件监听机制");15 setLayout(newFlowLayout());16 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);17

18 btn=new JButton("点击");19 btn.addActionListener(this);20 getContentPane().add(btn);21

22 setBounds(200,200,300,160);23 setVisible(true);24 }25

26 /**************************************/

27 public voidactionPerformed (ActionEvent e){28 Container c=getContentPane();29 c.setBackground(Color.red);30 }31 /**************************************/

32

33 public static voidmain(String args[]){34 newThisClassEvent();35 }36 }

外部类作为事件监听器:

1 import java.awt.*;2 import java.awt.event.*;3 import javax.swing.*;4

5 /**

6 *Java事件处理机制:外部类作为事件监听器7 *@authorWinty(wintys@gmail.com)8 *@version2008-12-39 */

10 class OuterClassEvent extendsJFrame{11 JButton btn;12

13 publicOuterClassEvent(){14 super("Java事件监听机制");15 setLayout(newFlowLayout());16 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);17

18 btn=new JButton("点击");19 btn.addActionListener(new OuterClass(this));20 getContentPane().add(btn);21

22 setBounds(200,200,300,160);23 setVisible(true);24 }25

26 public static voidmain(String args[]){27 newOuterClassEvent();28 }29 }30

31 /*外部类*********************************/

32 class OuterClass implementsActionListener{33 OuterClassEvent oce;34

35 publicOuterClass(OuterClassEvent oce){36 this.oce =oce;37 }38

39 public voidactionPerformed(ActionEvent e){40 Container c=oce.getContentPane();41 c.setBackground(Color.red);42 }43 }

匿名内部类作为事件监听器:

import java.awt.*;import java.awt.event.*;import javax.swing.*;/***Java事件处理机制:匿名内部类作为事件监听器

*@authorWinty(wintys@gmail.com)

*@version2008-12-3*/

class AnonymousEvent extendsJFrame{

JButton btn;publicAnonymousEvent(){super("Java事件监听机制");

setLayout(newFlowLayout());

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

btn=new JButton("点击");/*匿名内部类******************************/btn.addActionListener(newActionListener(){public voidactionPerformed(ActionEvent e){

Container c=getContentPane();

c.setBackground(Color.red);

}

}

);/***************************************/getContentPane().add(btn);

setBounds(200,200,300,160);

setVisible(true);

}public static voidmain(String args[]){newAnonymousEvent();

}

}

内部类作为事件监听器:

import java.awt.*;import java.awt.event.*;import javax.swing.*;/***Java事件处理机制:内部类作为事件监听器

*@authorWinty(wintys@gmail.com)

*@version2008-12-3*/

class InnerClassEvent extendsJFrame{

JButton btn;publicInnerClassEvent(){super("Java事件监听机制");

setLayout(newFlowLayout());

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

btn=new JButton("点击");

btn.addActionListener(newInnerClass());

getContentPane().add(btn);

setBounds(200,200,300,160);

setVisible(true);

}/*内部类*********************************/

class InnerClass implementsActionListener{public voidactionPerformed (ActionEvent e){

Container c=getContentPane();

c.setBackground(Color.red);

}

}/**************************************/

public static voidmain(String args[]){newInnerClassEvent();

}

}

什么是监听器

监听器就是一个实现特定接口的普通java程序，这个程序专门用于监听另一个java对象的方法调用或属性改变，当被监听对象发生上述事件后，监听器某个方法将立即被执行。。

为什么我们要使用监听器？

监听器可以用来检测网站的在线人数，统计网站的访问量等等！

监听器组件

监听器涉及三个组件：事件源，事件对象，事件监听器

当事件源发生某个动作的时候，它会调用事件监听器的方法，并在调用事件监听器方法的时候把事件对象传递进去。

我们在监听器中就可以通过事件对象获取得到事件源，从而对事件源进行操作！

模拟监听器

既然上面已经说了监听器的概念了，监听器涉及三个组件：事件源，事件对象，事件监听器。

我们就写一个对象，被监听器监听

监听器

监听器定义为接口，监听的方法需要事件对象传递进来，从而在监听器上通过事件对象获取得到事件源，对事件源进行修改！

/*** 事件监听器** 监听Person事件源的eat和sleep方法*/

interfacePersonListener{

voiddoEat(Event event);

voiddoSleep(Event event);

}

事件源

事件源是一个Person类，它有eat和sleep()方法。

事件源需要注册监听器(即在事件源上关联监听器对象)

如果触发了eat或sleep()方法的时候，会调用监听器的方法，并将事件对象传递进去

/**** 事件源Person** 事件源要提供方法注册监听器(即在事件源上关联监听器对象)*/

classPerson {

//在成员变量定义一个监听器对象

private PersonListener personListener ;

//在事件源中定义两个方法

publicvoidEat() {

//当事件源调用了Eat方法时，应该触发监听器的方法，调用监听器的方法并把事件对象传递进去

personListener.doEat(new Event(this));

}

publicvoidsleep() {

//当事件源调用了Eat方法时，应该触发监听器的方法，调用监听器的方法并把事件对象传递进去

personListener.doSleep(new Event(this));

}

//注册监听器，该类没有监听器对象啊，那么就传递进来吧。

publicvoidregisterLister(PersonListener personListener) {

this.personListener = personListener;

}

}

事件对象

事件对象封装了事件源。

监听器可以从事件对象上获取得到事件源的对象(信息)

/*** 事件对象Even** 事件对象封装了事件源** 在监听器上能够通过事件对象获取得到事件源***/

classEvent{

private Person person;

publicEvent() {

}

publicEvent(Person person) {

this.person = person;

}

publicPerson getResource() {

return person;

}

}

测试

publicstaticvoidmain(String[] args) {

Person person = new Person();

//注册监听器()

person.registerLister(new PersonListener() {

@Override

publicvoiddoEat(Event event) {

Person person1 = event.getResource();

System.out.println(person1 + "正在吃饭呢！");

}

@Override

publicvoiddoSleep(Event event) {

Person person1 = event.getResource();

System.out.println(person1 + "正在睡觉呢！");

}

});

//当调用eat方法时，触发事件，将事件对象传递给监听器，最后监听器获得事件源，对事件源进行操作

person.Eat();

}

事件源：拥有事件

监听器：监听事件源所拥有的事件(带事件对象参数的)

事件对象：事件对象封装了事件源对象

事件源要与监听器有关系，就得注册监听器【提供方法得到监听器对象】

触发事件源的事件，实际会提交给监听器对象处理，并且把事件对象传递过去给监听器。

Servlet监听器

在Servlet规范中定义了多种类型的监听器，它们用于监听的事件源分别 ServletContext, HttpSession和ServletRequest这三个域对象

和其它事件监听器略有不同的是，servlet监听器的注册不是直接注册在事件源上，而是由WEB容器负责注册，开发人员只需在web.xml文件中使用标签配置好监听器，

监听对象的创建和销毁

HttpSessionListener、ServletContextListener、ServletRequestListener分别监控着Session、Context、Request对象的创建和销毁

HttpSessionListener(可以用来收集在线者信息)

ServletContextListener(可以获取web.xml里面的参数配置)

ServletRequestListener

测试

public classListener1 implementsServletContextListener,

HttpSessionListener, ServletRequestListener {

// Public constructor is required by servlet spec

publicListener1() {

}

publicvoidcontextInitialized(ServletContextEvent sce) {

System.out.println("容器创建了");

}

publicvoidcontextDestroyed(ServletContextEvent sce) {

System.out.println("容器销毁了");

}

publicvoidsessionCreated(HttpSessionEvent se) {

System.out.println("Session创建了");

}

publicvoidsessionDestroyed(HttpSessionEvent se) {

System.out.println("Session销毁了");

}

@Override

publicvoidrequestDestroyed(ServletRequestEvent servletRequestEvent) {

}

@Override

publicvoidrequestInitialized(ServletRequestEvent servletRequestEvent) {

}

}

监听器监听到ServletContext的初始化了，Session的创建和ServletContext的销毁。(服务器停掉，不代表Session就被销毁了。Session的创建是在内存中的，所以没看到Session被销毁了)

监听对象属性变化

ServletContextAttributeListener、HttpSessionAttributeListener、ServletRequestAttributeListener分别监听着Context、Session、Request对象属性的变化

这三个接口中都定义了三个方法来处理被监听对象中的属性的增加，删除和替换的事件，同一个事件在这三个接口中对应的方法名称完全相同，只是接受的参数类型不同。

attributeAdded()

attributeRemoved()

attributeReplaced()

测试

这里我只演示Context对象，其他对象都是以此类推的，就不一一测试了。

实现ServletContextAttributeListener接口。

public classListener1 implementsServletContextAttributeListener {

@Override

publicvoidattributeAdded(ServletContextAttributeEvent servletContextAttributeEvent) {

System.out.println("Context对象增加了属性");

}

@Override

publicvoidattributeRemoved(ServletContextAttributeEvent servletContextAttributeEvent) {

System.out.println("Context对象删除了属性");

}

@Override

publicvoidattributeReplaced(ServletContextAttributeEvent servletContextAttributeEvent) {

System.out.println("Context对象替换了属性");

}

}

测试的Servlet

protectedvoiddoPost(HttpServletRequest request, HttpServletResponse response) throwsServletException, IOException {

ServletContext context = this.getServletContext();

context.setAttribute("aa", "123");

context.setAttribute("aa", "234");

context.removeAttribute("aa");

}

监听Session内的对象

除了上面的6种Listener，还有两种Linstener监听Session内的对象，分别是HttpSessionBindingListener和HttpSessionActivationListener，实现这两个接口并不需要在web.xml文件中注册

实现HttpSessionBindingListener接口，JavaBean 对象可以感知自己被绑定到 Session 中和从 Session 中删除的事件【和HttpSessionAttributeListener的作用是差不多的】

实现HttpSessionActivationListener接口，JavaBean 对象可以感知自己被活化和钝化的事件(当服务器关闭时，会将Session的内容保存在硬盘上【钝化】，当服务器开启时，会将Session的内容在硬盘式重新加载【活化】) 。。

想要测试出Session的硬化和钝化，需要修改Tomcat的配置的。在META-INF下的context.xml文件中添加下面的代码：

测试

监听器和事件源

/** 由于涉及到了将内存的Session钝化到硬盘和用硬盘活化到内存中，所以需要实现Serializable接口** 该监听器是不需要在web.xml文件中配置的。但监听器要在事件源上实现接口* 也就是说，直接用一个类实现HttpSessionBindingListener和HttpSessionActivationListener接口是监听不到Session内对象的变化的。* 因为它们是感知自己在Session中的变化！* */

public classUser implementsHttpSessionBindingListener,HttpSessionActivationListener,Serializable {

private String username ;

publicString getUsername() {

return username;

}

publicvoidsetUsername(String username) {

this.username = username;

}

@Override

publicvoidsessionWillPassivate(HttpSessionEvent httpSessionEvent) {

HttpSession httpSession = httpSessionEvent.getSession();

System.out.println("钝化了");

}

@Override

publicvoidsessionDidActivate(HttpSessionEvent httpSessionEvent) {

HttpSession httpSession = httpSessionEvent.getSession();

System.out.println("活化了");

}

@Override

publicvoidvalueBound(HttpSessionBindingEvent httpSessionBindingEvent) {

System.out.println("绑定了对象");

}

@Override

publicvoidvalueUnbound(HttpSessionBindingEvent httpSessionBindingEvent) {

System.out.println("解除了对象");

}

}

测试代码

User user = new User();

request.getSession().setAttribute("aaa", user);

request.getSession().removeAttribute("aaa");

效果：

收起

展开全文
JAVA事件监听器的四种实现方式
2012-02-27 09:44:23

JAVA事件监听器的四种实现方式，条理清晰，简明易懂，看过就学会

收起

java事件监听

千次阅读 2021-12-26 15:41:47

Java中java.swt.event包包含了不同事件的类和接口，每个事件类一般有对应于一个事件监听器接口文章目录前言一、事件监听器监听器的注册事件处理的具体步骤动作事件ActionEvent二、适配器类使用内部类来进行监听...

Java中java.swt.event包包含了不同事件的类和接口，每个事件类一般有对应于一个事件监听器接口

前言

提示：这里可以添加本文要记录的大概内容：例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

提示：以下是本篇文章正文内容，下面案例可供参考

一、事件监听器

事件监听器是某个类的对象，我们将这个类称为监听器类

监听器必须要由监听和处理XXXEvent事件的能力，他所在的类必须要实现XXXListener接口

监听器的注册

所有组件都从Conponent类中继承了将事件处理授权给监听器的方法，又称为注册

component.addXXXListener(Listener);

取消注册

component.removeXXXListener(Listener);

事件处理的具体步骤

在这里插入图片描述

动作事件ActionEvent

动作事件是最常见的一类事件，当鼠标单击按钮，复选框，单选按钮或者菜单和文本框中输入回车时都会出发ActionEvent事件

负责处理ActionEvent事件的监听器必须实现ActionLister接口，实现接口里面的方法actionPerformed（）的方法，事件处理代码就在这个方法里面

举例

在这里插入图片描述

package action;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.*;

public class action_demo implements ActionListener {
	JFrame frame;
	JButton button;
	
	public action_demo() {
		// TODO Auto-generated constructor stub
		frame = new JFrame("动作事件");
		button = new JButton("确定");
		button.addActionListener(this);
		frame.add(button);
		frame.setSize(240,100);
		frame.setVisible(true);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		frame.setTitle("单击了确定按钮");
	}
	
	public static void main(String[] args) {
		new action_demo();
	}
}

ActionEvent事件常用的方法
getActionCommand（）返回与此动作相关的字符串
eg. 当点击“确定” 按钮，返回时字符串“确定”
getSource（）返回事件源
eg. 当点击“确定”按钮时，返回按钮对象名button

package action;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.*;

public class action_demo implements ActionListener {
	JFrame frame;
	JPanel panel;
	JButton button1,button2;
	
	public action_demo() {
		// TODO Auto-generated constructor stub
		frame = new JFrame("动作事件");
		button1 = new JButton("确定");
		button1.addActionListener(this);
		button2 = new JButton("取消");
		button2.addActionListener(this);
		panel = new JPanel();
		panel.add(button1);
		panel.add(button2);
		frame.add(panel);
		frame.setSize(240,100);
		frame.setVisible(true);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		if(e.getSource() == button1)
			frame.setTitle("单击了确定按钮");
		else {
			frame.setTitle("单击了取消按钮");
		}
	}
	
	public static void main(String[] args) {
		new action_demo();
	}
}

二、适配器类

当在某个类中实现了事件监听接口，则要实现其左右方法，为了避免这种情况，则有适配器，使用方法直接在类的后面加上 extends XXXAdapter

在这里插入图片描述

使用内部类来进行监听

代码如下（示例）：

package action;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.*;

public class action_demo{
	JFrame frame;
	JPanel panel;
	JButton button1,button2;
	
	public action_demo() {
		// TODO Auto-generated constructor stub
		frame = new JFrame("动作事件");
		button1 = new JButton("确定");
		button1.addActionListener(new ActionListener() {

			@Override
			public void actionPerformed(ActionEvent e) {
				// TODO Auto-generated method stub
				frame.setTitle("单击了确定按钮");
			}
			
		});
		button2 = new JButton("取消");
		button2.addActionListener(new ActionListener() {

			@Override
			public void actionPerformed(ActionEvent e) {
				// TODO Auto-generated method stub
				frame.setTitle("单击了取消按钮");
			}
			
		});
		panel = new JPanel();
		panel.add(button1);
		panel.add(button2);
		frame.add(panel);
		frame.setSize(240,100);
		frame.setVisible(true);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}

//	@Override
//	public void actionPerformed(ActionEvent e) {
//		// TODO Auto-generated method stub
//		if(e.getSource() == button1)
//			frame.setTitle("单击了确定按钮");
//		else {
//			frame.setTitle("单击了取消按钮");
//		}
//	}
	
	public static void main(String[] args) {
		new action_demo();
	}
}

鼠标事件

在这里插入图片描述

java事件监听器

千次阅读 2019-12-20 17:30:12

动作事件（ActionEvent）监听器是Swing中比较常用的事件监听器，很组件的动作都会使用它监听，如按钮单击，下表描述了动作事件监听器的接口与事件源。事件名称事件源监听接口添加或删除相应类型监听器...

1.动作事件监听器

动作事件（ActionEvent）监听器是Swing中比较常用的事件监听器，很组件的动作都会使用它监听，如按钮单击，下表描述了动作事件监听器的接口与事件源。

事件名称	事件源	监听接口	添加或删除相应类型监听器的方法
ActionEvent	JButton、JList、JTextField等	ActionListener	addActionListener()、removeActionListener()

动作事件监听器可以为按钮、列表、列表框、文本等组件进行监听，下面以按钮为例将讲解动作监听器的用法，代码如下：


import java.awt.*;
import java.awt.event.*;

import javax.swing.*;

public class Dpc extends JFrame{

	private JButton jb=new JButton("我是按钮，单击我");
	public Dpc(){
		setLayout(null);
		setSize(200,100);
		setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
		Container cp=getContentPane();
		cp.add(jb);
		jb.setBounds(10, 10,100,30);
		//对按钮添加监听器
		jb.addActionListener(new jbAction());
		setVisible(true);
	}
	//创建监听器接口
	class jbAction implements ActionListener{
		public void actionPerformed(ActionEvent arg0) {
			jb.setText("我被单击了");
		}
	}
	public static void main(String[] args) {
		new Dpc();
	}
}

返回结果：

在上述实例中，为按钮设置了动作事件监听器，由于获取事件监听时需要获取实现ActionListener接口的对象，所以定义了一个内部类JbAction，来实现ActionListener接口，同时在该内部类中实现了actionPerformed方法，也就是在actionPerformed()方法中定义当用户单击该按钮后的实现效果。

上述代码中也可以这么写，把内部类写在jb.addActionListener(）中，代码如下：

jb.addActionListener(new ActionListener() {
	public void actionPerformed(ActionEvent arg0) {
		jb.setText("我被单击了");
	}
});

2.键盘事件

当向文本框中输入文本内容时，将触发键盘事件，keyEvent类负责捕获键盘事件，可以通过为组件添加实现了KeyListener接口的监听器类，来处理该组件触发的键盘事件。KeyListener接口共有三个抽象方法，分别发生在击键事件（按下并释放键）、按键被按下（手指按下键但不松开）和按键被释放（手指从按下的键上松开）时被触发。KeyListener接口的具体定义如下：

public interface KeyEvent extends EventListener{
	//发生击键事件时被触发
	public void keyTyped(keyEvent e);
	//按键被按下时被触发
	public void keyPressed(keyEvent e);
	//按键被释放时被触发
	public void keyReleased(keyEvent e);
}

在每个抽象方法中均传入了KeyEvent类对象，KeyEvent类中比较常用的方法如下表：

方法	功能简介
getSource()	用来获取触发此事件的组件对象，返回值Object对象
getKeyChar()	用来获得与此事件中的键相关联字符
getKeyCode()	用来获得与此事件中的键相关联的整数keyCode
getrKeyText(int keyCode)	用来获得描述keyCode的标签，如A、F1和HOME等
isActionKey()	用来查看此事件中的键是否为"动作"键
isControlDown()	用来查看Ctrl键在此事件中是否被按下，当返回true时表示被按下
isAltDown()	用来查看Alt键在此事件中是否被按下，当返回true时表示被按下
isShiftDown()	用来查看Shift键在此事件中是否被按下，当返回true时表示被按下

下面通过一个例子在演示键盘事件的用法，代码如下：

import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class Demo extends JFrame{
	public Demo() {
		Container ct = getContentPane();
		ct.setLayout(new GridLayout(2,1,10,10));
		setBounds(100, 100, 200, 100);
		
		//设置面板
		JPanel jp1 = new JPanel(new FlowLayout());
		JPanel jp2 = new JPanel(new FlowLayout());
		
		//设置文本框
		JTextField jt = new JTextField();
		jt.setColumns(10);
		jp1.add(jt);

		//设置标签
		JLabel jl = new JLabel();
		jp2.add(jl);
		//设置键盘事件
		jt.addKeyListener(new KeyListener() {
			//按键被按下时被触发
			public void keyReleased(KeyEvent e) {
				//清空文本框内容
				jt.setText("");				
			}
			//按键被按下时被触发
			public void keyPressed(KeyEvent e) {
				jl.setText("你输入的字符为：" + e.getKeyChar());			
			}
			public void keyTyped(KeyEvent e) {
	
			}
		});
		//将面板添加到容器
		ct.add(jp1);
		ct.add(jp2);
		
		setVisible(true);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		
	}
	public static void main(String[] args) {
		new Demo();
	}
}

返回结果：

以下是模拟键盘的代码：


import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import java.awt.Color;
import java.awt.Component;

import javax.swing.JButton;
import java.awt.Font;
import javax.swing.SwingConstants;
import javax.swing.border.TitledBorder;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.ArrayList;

import javax.swing.JTextField;

/**
 * 虚拟键盘(键盘的按下与释放)
 */
public class Dpc extends JFrame { //创建“键盘”类继承JFrame
	//声明窗体中的成员组件
	private JPanel contentPane;
	private JTextField textField;
	private JButton btnQ;
	private JButton btnW;
	private JButton btnE;
	private JButton btnR;
	private JButton btnT;
	private JButton btnY;
	private JButton btnU;
	private JButton btnI;
	private JButton btnO;
	private JButton btnP;
	private JButton btnA;
	private JButton btnS;
	private JButton btnD;
	private JButton btnF;
	private JButton btnG;
	private JButton btnH;
	private JButton btnJ;
	private JButton btnK;
	private JButton btnL;
	private JButton btnZ;
	private JButton btnX;
	private JButton btnC;
	private JButton btnV;
	private JButton btnB;
	private JButton btnN;
	private JButton btnM;
	Color green=Color.GREEN;//定义Color对象，用来表示按下键的颜色
	Color white=Color.WHITE;//定义Color对象，用来表示释放键的颜色
	
	ArrayList<JButton> btns=new ArrayList<JButton>();//定义一个集合，用来存储所有的按键ID
	//自定义一个方法，用来将容器中的所有JButton组件添加到集合中
	private void addButtons(){
		for(Component cmp :contentPane.getComponents()){//遍历面板中的所有组件
			if(cmp instanceof JButton){//判断组件的类型是否为JButton类型
				btns.add((JButton)cmp);//将JButton组件添加到集合中
			}
		}
	}

	/**
	 * 主方法
	 */
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() { //使得Runnable中的的run()方法在the system EventQueue的指派线程中被调用
			public void run() {
				try {
					Dpc frame = new Dpc(); //创建KeyBoard对象
					frame.setVisible(true); //使frame可视
					frame.addButtons();//初始化存储所有按键的集合
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	/**
	 * 创建JFrame窗体
	 */
	public Dpc() { //KeyBoard的构造方法
		setTitle("\u865A\u62DF\u952E\u76D8\uFF08\u6A21\u62DF\u952E\u76D8\u7684\u6309\u4E0B\u4E0E\u91CA\u653E\uFF09"); //设置窗体题目
		setResizable(false); //不可改变窗体宽高
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //设置窗体关闭的方式
		setBounds(100, 100, 548, 280); //设置窗体的位置和宽高
		/**
		 * 创建JPanel面板contentPane置于JFrame窗体中，并设置面板的背景色、边距和布局
		 */
		contentPane = new JPanel();
		contentPane.setBackground(Color.WHITE);
		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
		setContentPane(contentPane);
		contentPane.setLayout(null);
		/**
		 * 创建按钮button置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnQ = new JButton("Q");
		btnQ.setBackground(white);
		btnQ.setVerticalAlignment(SwingConstants.TOP);
		btnQ.setHorizontalAlignment(SwingConstants.LEADING);
		btnQ.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnQ.setBounds(0, 60, 47, 45);
		contentPane.add(btnQ);
		/**
		 * 创建按钮button_2置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnW = new JButton("W");
		btnW.setBackground(white);
		btnW.setVerticalAlignment(SwingConstants.TOP);
		btnW.setHorizontalAlignment(SwingConstants.LEADING);
		btnW.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnW.setBounds(55, 60, 49, 45);
		contentPane.add(btnW);
		/**
		 * 创建按钮button_3置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnE = new JButton("E");
		btnE.setBackground(white);
		btnE.setVerticalAlignment(SwingConstants.TOP);
		btnE.setHorizontalAlignment(SwingConstants.LEADING);
		btnE.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnE.setBounds(110, 60, 45, 45);
		contentPane.add(btnE);
		/**
		 * 创建按钮button_4置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnR = new JButton("R");
		btnR.setBackground(white);
		btnR.setVerticalAlignment(SwingConstants.TOP);
		btnR.setHorizontalAlignment(SwingConstants.LEADING);
		btnR.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnR.setBounds(165, 60, 45, 45);
		contentPane.add(btnR);
		/**
		 * 创建按钮button_5置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnF = new JButton("F");
		btnF.setBackground(white);
		btnF.setVerticalAlignment(SwingConstants.TOP);
		btnF.setHorizontalAlignment(SwingConstants.LEADING);
		btnF.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnF.setBounds(195, 125, 45, 45);
		contentPane.add(btnF);
		/**
		 * 创建按钮button_6置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnD = new JButton("D");
		btnD.setBackground(white);
		btnD.setVerticalAlignment(SwingConstants.TOP);
		btnD.setHorizontalAlignment(SwingConstants.LEADING);
		btnD.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnD.setBounds(137, 125, 45, 45);
		contentPane.add(btnD);
		
		btnT = new JButton("T");
		btnT.setVerticalAlignment(SwingConstants.TOP);
		btnT.setHorizontalAlignment(SwingConstants.LEADING);
		btnT.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnT.setBackground(white);
		btnT.setBounds(220, 60, 45, 45);
		contentPane.add(btnT);
		
		btnY = new JButton("Y");
		btnY.setVerticalAlignment(SwingConstants.TOP);
		btnY.setHorizontalAlignment(SwingConstants.LEADING);
		btnY.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnY.setBackground(white);
		btnY.setBounds(275, 60, 45, 45);
		contentPane.add(btnY);
		
		btnU = new JButton("U");
		btnU.setVerticalAlignment(SwingConstants.TOP);
		btnU.setHorizontalAlignment(SwingConstants.LEADING);
		btnU.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnU.setBackground(white);
		btnU.setBounds(330, 60, 45, 45);
		contentPane.add(btnU);
		
		btnI = new JButton("I");
		btnI.setVerticalAlignment(SwingConstants.TOP);
		btnI.setHorizontalAlignment(SwingConstants.LEADING);
		btnI.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnI.setBackground(white);
		btnI.setBounds(385, 60, 45, 45);
		contentPane.add(btnI);
		
		btnO = new JButton("O");
		btnO.setVerticalAlignment(SwingConstants.TOP);
		btnO.setHorizontalAlignment(SwingConstants.LEADING);
		btnO.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnO.setBackground(white);
		btnO.setBounds(440, 60, 46, 45);
		contentPane.add(btnO);
		
		btnP = new JButton("P");
		btnP.setVerticalAlignment(SwingConstants.TOP);
		btnP.setHorizontalAlignment(SwingConstants.LEADING);
		btnP.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnP.setBackground(white);
		btnP.setBounds(495, 60, 45, 45);
		contentPane.add(btnP);
		
		btnA = new JButton("A");
		btnA.setVerticalAlignment(SwingConstants.TOP);
		btnA.setHorizontalAlignment(SwingConstants.LEADING);
		btnA.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnA.setBackground(white);
		btnA.setBounds(23, 125, 45, 45);
		contentPane.add(btnA);
		
		btnS = new JButton("S");
		btnS.setVerticalAlignment(SwingConstants.TOP);
		btnS.setHorizontalAlignment(SwingConstants.LEADING);
		btnS.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnS.setBackground(white);
		btnS.setBounds(82, 125, 45, 45);
		contentPane.add(btnS);
		
		btnG = new JButton("G");
		btnG.setVerticalAlignment(SwingConstants.TOP);
		btnG.setHorizontalAlignment(SwingConstants.LEADING);
		btnG.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnG.setBackground(white);
		btnG.setBounds(251, 125, 45, 45);
		contentPane.add(btnG);
		
		btnH = new JButton("H");
		btnH.setVerticalAlignment(SwingConstants.TOP);
		btnH.setHorizontalAlignment(SwingConstants.LEADING);
		btnH.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnH.setBackground(white);
		btnH.setBounds(306, 125, 45, 45);
		contentPane.add(btnH);
		
		btnJ = new JButton("J");
		btnJ.setVerticalAlignment(SwingConstants.TOP);
		btnJ.setHorizontalAlignment(SwingConstants.LEADING);
		btnJ.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnJ.setBackground(white);
		btnJ.setBounds(361, 125, 45, 45);
		contentPane.add(btnJ);
		
		btnK = new JButton("K");
		btnK.setVerticalAlignment(SwingConstants.TOP);
		btnK.setHorizontalAlignment(SwingConstants.LEADING);
		btnK.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnK.setBackground(white);
		btnK.setBounds(416, 125, 47, 45);
		contentPane.add(btnK);
		
		btnL = new JButton("L");
		btnL.setVerticalAlignment(SwingConstants.TOP);
		btnL.setHorizontalAlignment(SwingConstants.LEADING);
		btnL.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnL.setBackground(white);
		btnL.setBounds(471, 125, 45, 45);
		contentPane.add(btnL);
		
		btnZ = new JButton("Z");
		btnZ.setVerticalAlignment(SwingConstants.TOP);
		btnZ.setHorizontalAlignment(SwingConstants.LEADING);
		btnZ.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnZ.setBackground(white);
		btnZ.setBounds(39, 190, 45, 45);
		contentPane.add(btnZ);
		
		btnX = new JButton("X");
		btnX.setVerticalAlignment(SwingConstants.TOP);
		btnX.setHorizontalAlignment(SwingConstants.LEADING);
		btnX.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnX.setBackground(white);
		btnX.setBounds(107, 190, 45, 45);
		contentPane.add(btnX);
		
		btnC = new JButton("C");
		btnC.setVerticalAlignment(SwingConstants.TOP);
		btnC.setHorizontalAlignment(SwingConstants.LEADING);
		btnC.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnC.setBackground(white);
		btnC.setBounds(178, 190, 45, 45);
		contentPane.add(btnC);
		
		btnV = new JButton("V");
		btnV.setVerticalAlignment(SwingConstants.TOP);
		btnV.setHorizontalAlignment(SwingConstants.LEADING);
		btnV.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnV.setBackground(white);
		btnV.setBounds(250, 190, 45, 45);
		contentPane.add(btnV);
		
		btnB = new JButton("B");
		btnB.setVerticalAlignment(SwingConstants.TOP);
		btnB.setHorizontalAlignment(SwingConstants.LEADING);
		btnB.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnB.setBackground(white);
		btnB.setBounds(315, 190, 45, 45);
		contentPane.add(btnB);
		
		btnN = new JButton("N");
		btnN.setVerticalAlignment(SwingConstants.TOP);
		btnN.setHorizontalAlignment(SwingConstants.LEADING);
		btnN.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnN.setBackground(white);
		btnN.setBounds(382, 190, 47, 45);
		contentPane.add(btnN);
		
		btnM = new JButton("M");
		btnM.setVerticalAlignment(SwingConstants.TOP);
		btnM.setHorizontalAlignment(SwingConstants.LEADING);
		btnM.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnM.setBackground(white);
		btnM.setBounds(449, 190, 48, 45);
		contentPane.add(btnM);
		/**
		 * 创建面板panel置于面板contentPane中，设置面板panel的位置、宽高、TitledBorder、背景色以及布局方式（边界布局）
		 */
		JPanel panel = new JPanel();
		panel.setBorder(new TitledBorder(null, "文本显示区", TitledBorder.LEADING, TitledBorder.TOP, null, null));
		panel.setBackground(Color.WHITE);
		panel.setBounds(0, 0, 540, 45);
		contentPane.add(panel);
		panel.setLayout(new BorderLayout(0, 0));
		
		
		/**
		 * 创建文本框textField置于面板panel的中间
		 */
		textField = new JTextField();
		textField.addKeyListener(new KeyAdapter() { //文本框添加键盘事件的监听
			char word;
			@Override
			public void keyPressed(KeyEvent e) { //按键被按下时被触发
				word=e.getKeyChar();//获取按下键表示的字符
				for(int i=0;i<btns.size();i++){//遍历存储按键ID的ArrayList集合
					//判断按键是否与遍历到的按键的文本相同
					if(String.valueOf(word).equalsIgnoreCase(btns.get(i).getText())){
						btns.get(i).setBackground(green);//将指定按键颜色设置为绿色
					}
				}
			}
			@Override
			public void keyReleased(KeyEvent e) { //按键被释放时被触发
				word=e.getKeyChar();//获取释放键表示的字符
				for(int i=0;i<btns.size();i++){//遍历存储按键ID的ArrayList集合
					//判断按键是否与遍历到的按键的文本相同
					if(String.valueOf(word).equalsIgnoreCase(btns.get(i).getText())){
						btns.get(i).setBackground(white);//将指定按键颜色设置为白色
					}
				}
			}
		});
		panel.add(textField, BorderLayout.CENTER);
		textField.setColumns(10);
	}
}

返回结果：

3.鼠标事件

所有组件都能应用鼠标事件，MouseEvent类负责捕获鼠标事件，可以通过为组件添加实现了MouseListener接口的监听器类来处理该组件触发的鼠标事件，

MouseListener接口共有5个抽象方法，分别在光标移入或移出组件、鼠标按键被按下或释放和发生单击事件时被触发，所谓单击事件，就是鼠标按键被按下并释放，需要注意的是，如果鼠标按键是在移出组件之后被释放，则不会触发单击事件，接口中各个方法的代码如下：

public void mouseReleased(MouseEvent e) {
    //鼠标按键被释放时被触发
}

public void mousePressed(MouseEvent e) {
	//鼠标按键被按下时被触发
}

public void mouseExited(MouseEvent e) {
	//光标移出组件时被触发	
}

public void mouseEntered(MouseEvent e) {
    //光标移入组件时被触发
}

public void mouseClicked(MouseEvent e) {
	//发生单击事件时被触发
}

在每个抽象方法中均转入了MouseEvent类的对象，MouseEvent类中比较常用的方法如下表：

方法	功能简介
getSource()	用来获得触发此事件的组件对象，返回值为Object类型
getButton()	用来获得代表此次被按下、被释放或被单击的按键的int值
getClickCount()	用来获得按键被单击的次数

当需要判断触发此次事件的鼠标按键时，可以通过比较由getButton()方法返回的int值和下表中的静态常量的方式获得：

静态常量	常量值	代表的键
BUTTON1	1	代表鼠标左键
BUTTON2	2	代表鼠标滚轮
BUTTON3	3	代表鼠标右键

下面实例讲解鼠标事件，代码如下：

import java.awt.Color;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;


import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.border.LineBorder;

public class Demo extends JFrame{
	public Demo() {
		Container ct = getContentPane();
		setBounds(200, 200, 500, 300);
		ct.setLayout(null);
		//创建滚动面板
		JScrollPane jsc = new JScrollPane();
		jsc.setBounds(32, 27, 183, 216);
		ct.add(jsc);
		//创建文本域
		JTextArea jt = new JTextArea();
		jsc.setViewportView(jt);
		//创建标签
		JLabel jl = new JLabel();
		jl.setBounds(244, 57, 160, 141);
		jl.setBorder(new LineBorder(Color.red));
		ct.add(jl);
		//创建鼠标区域标签
		JLabel jl1 = new JLabel("鼠标点击区域");
		jl1.setBounds(281, 32, 84, 15);
		ct.add(jl1);
		//给鼠标区域标签创建鼠标事件
		jl.addMouseListener(new MouseListener() {
			//鼠标按键被释放时被触发
			public void mouseReleased(MouseEvent e) {
				jt.append("鼠标释放\n");
				
			}
			//鼠标按键被按下时被触发
			public void mousePressed(MouseEvent e) {
				jt.append("鼠标按下\n");
				
			}
			//光标移出组件时被触发
			public void mouseExited(MouseEvent e) {
				jt.append("光标移出\n");
				
			}
			//光标移入组件时被触发
			public void mouseEntered(MouseEvent e) {
				jt.append("光标移入\n");
			}
			//发生单击事件时被触发
			public void mouseClicked(MouseEvent e) {
				int sum = e.getClickCount();
				int i = e.getButton(); // 通过该值可以判断按下的是哪个键
				if (i == MouseEvent.BUTTON1)
					jt.append("按下的是鼠标左键\n");
				else if (i == MouseEvent.BUTTON2)
					jt.append("按下的是鼠标滚轮\n");
				else if (i == MouseEvent.BUTTON3)
					jt.append("按下的是鼠标右键\n");
				
				jt.append("鼠标单击" + sum + "次\n");
				
			}
		});
		setVisible(true);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
	}
	public static void main(String[] args) {
		new Demo();
	}
}

返回结果：

4.窗体事件

需要捕获与窗体有关的事件时（如捕获窗体被打开、将要被关闭、已经被关闭事件），可以通过实现了WindowListener接口的事件监听器完成，WindowListener接口中各个方法的代码如下：

	
		public void windowActivated(WindowEvent e) {
	        // 窗体被激活时触发
		}

		public void windowOpened(WindowEvent e) {
            // 窗体被打开时触发
		}

		public void windowIconified(WindowEvent e) {
	        // 窗体被最小化时触发
		}

		public void windowDeiconified(WindowEvent e) {
	        // 窗体被非最小化时触发
		}

		public void windowClosing(WindowEvent e) {
            // 窗体将要被关闭时触发
		}

		public void windowDeactivated(WindowEvent e) {
            // 窗体不再处于激活状态时触发
		}

		public void windowClosed(WindowEvent e) {
	        // 窗体已经被关闭时触发
		}

窗体激活事件和窗体获得焦点事件的区别如下：

窗体激活事件时WindowListener接口中提供的事件，而窗体获得焦点事件是WindowFocusListener接口中提供的；
执行顺序不同：窗体激活→获得焦点→失去焦点→窗体不处于被激活状态；

通过捕获窗体将要被关闭事件，可以执行一些相关的操作，例如，窗体将要被关闭时，询问是否保存未保存的设置或者弹出确认关闭对话框等，下面是一个用来演示捕获窗体事件的典型实例：


import java.awt.event.WindowEvent;
import java.awt.event.WindowFocusListener;
import java.awt.event.WindowListener;

import javax.swing.JFrame;

public class Dpc extends JFrame {

	public static void main(String args[]) {
		Dpc frame = new Dpc();
		frame.setVisible(true);
	}

	public Dpc() {
		super();
		addWindowListener(new MyWindowListener());// 为窗体添加其他事件监听器
		setTitle("捕获其他窗体事件");
		setBounds(100, 100, 500, 375);
		setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
	}

	private class MyWindowListener implements WindowListener {
		public void windowActivated(WindowEvent e) {// 窗体被激活时触发
			System.out.println("窗口被激活！");
		}

		public void windowOpened(WindowEvent e) {// 窗体被打开时触发
			System.out.println("窗口被打开！");
		}

		public void windowIconified(WindowEvent e) {// 窗体被最小化时触发
			System.out.println("窗口被最小化！");
		}

		public void windowDeiconified(WindowEvent e) {// 窗体被非最小化时触发
			System.out.println("窗口被非最小化！");
		}

		public void windowClosing(WindowEvent e) {// 窗体将要被关闭时触发
			System.out.println("窗口将要被关闭！");
		}

		// 窗体不再处于激活状态时触发
		public void windowDeactivated(WindowEvent e) {
			System.out.println("窗口不再处于激活状态！");
		}

		public void windowClosed(WindowEvent e) {// 窗体已经被关闭时触发
			System.out.println("窗口已经被关闭！");
		}
	}
}

返回结果：

收起

展开全文

java事件监听模式实现万能事件总线.zip
2019-09-02 14:48:16

Java简单几个类实现万能事件总线，采用享元模式和监听器模式。使用方法很简单，直接EventCenter.get().addListener(key,()->{...你的代码快...});就行，无论在哪，只要执行EventCenter.get().sendMessage(key,...

收起
Java事件监听的四种实现方式
2021-03-15 10:45:30

importjava.awt.Color;importjava.awt.Container;importjava.awt.FlowLayout;importjava.awt.event.ActionEvent;importjava.awt.event.ActionListener;importjavax.swing.JButton;importjavax.swing.JDial...

收起
java监听器的实现和原理详解
2020-08-25 18:39:44

主要给大家介绍了关于java监听器实现和原理的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用java具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧

收起
java事件监听机制.doc
2019-06-07 15:26:18

java事件监听机制 java中的事件机制的参与者有3种角色： .event object：就是事件产生时具体的“事件”，用于listener的相应的方法之中，作为参数，一般存在与listerner的方法之中

收起
Java 事件监听器
千次阅读 2015-05-28 21:15:42

事件事件是用户在界面上的一个操作（通常使用各种输入设备，如：...事件类包含在java.awt.event和javax.swing.event包中。事件源产生事件的组件叫事件源。在一个按钮上单击鼠标时，该按钮就是事件源...

收起
事件监听机制（一）Java事件监听
万次阅读 2019-02-25 09:56:27

事件监听机制（一）Java事件监听事件监听实现流程 ...事件监听器负责监听事件源发出的事件，事件监听器可以通过实现java.util.EventListener这个标识接口.，实现事件监听。流程总结事件源可以注册...

收起
Java事件监听机制
2021-02-12 13:54:31

Java事件监听机制在Java图形界面编程处常用，比如我们写好这样一个图形界面程序：我们会对界面进行一些操作，比如输入框中输入数据，点击登录按钮等，这些操作被称之为事件，当采取这些操作后，程序应会采取一定的...

收起
java事件监听方法和代码
2012-06-29 15:31:34

Java事件监听器即一组动作接口。如键盘事件KeyEvent对应的接口是： public interface KeyListener extends EventListener { public void keyPressed(KeyEvent ev); public void keyReleased(KeyEvent ev); public ...

收起
JAVA事件监听器
千次阅读 2012-07-20 16:20:25

java事由事件类和监听接口组成，算定义一个事件前，必须提供一个事件的监听接口以及一个事件类。java中监听接口是继承自java.util.EventListener的，事件类继承自java.util.EventObject。很多基本的事件系统已经为...

收起

import class
Java事件处理机制-事件监听器的实现方式
2021-03-13 00:18:55

在Java的swing编程中,Java中的事件机制非常常用事件监听器的参与者：1.事件对象：一般继承自java.util.EventObject对象,由开发者自行定义.2.事件源：就是触发事件的源头,不同的事件源会触发不同的事件类型.3.事件...

收起
干货丨Java事件监听器的工作步骤介绍
2020-12-29 09:00:00

在程序开发中，经常需要对某些事件进行监听，如监听鼠标点击事件、监听键盘按下事件等，此时就需要使用事件监听器，事件监听器用于对程序中发生的事件进行监听，在监听的过程中会涉及几个重要组成部分...

收起

css spring 软件测试
java事件监听器原理
千次阅读 2017-10-06 12:51:25

java事件监听器分为三部分：事件，事件源，监听器。事件—事件状态对象,也就是发生了什么事件。用于listener的相应的方法之中，作为参数，一般存在与listerner的方法之中。（伴随着事件的发生，相应的状态通常都封装...

收起
Java中的事件监听器
2021-03-15 13:23:27

我们使用基类和事件侦听器来设计我们的应用程序，从而获得基类和事件侦听器接口。基类在调用任何操作后调用适当的事件侦听器方法。以下代码显示了我的设计：import java.util.EventListener;public interface ...

收起
Java常用事件监听器与实例分析，java面试架构设计
2021-12-10 15:00:13

我们知道在Java窗体中的组件，本身是不具备任何功能的，因此我们必须要给控件添加相应的事件监听，才能在界面中触发相应的事件处理，今天就来和大家分享一下在Java中常用的几个事件监听器。监听事件简介 ====== ...

收起

后端
java 事件监听（简单举例）
2021-04-24 16:33:20

事件模型三要素：事件对象，事件源，事件监听器 事件对象：表示发生了什么事事件源：表示是产生这个事件的对象 事件监听器：表示接收到对象后，对这个事件进行处理直接看代码：这是一个事件监听器的接口 //...

收起

event
java 事件监听器ActionListener
2021-03-06 02:55:38

/** 功能:java事件监听器ActionListener*/package com.events;import java.awt.BorderLayout;import java.awt.Color;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.*...

收起
Java实现一个简单的事件监听器
2021-02-12 16:42:29

a)事件三要素：source --事件源when--事件发生时间message-- 事件主题消息，即希望通过事件传递出去的信息b)事件流转过程：(1)事件源注册监听器 -> (2)事件发生 -> (3)通知监听器 -> (4)监听器处理那么基于...

收起
Java的事件监听器学习心得
2021-02-28 18:27:58

在Java的swing编程中,Java中的事件机制非常常用一. 事件监听器的参与者：1.事件对象：一般继承自java.util.EventObject...一个事件监听器通常实现java.util.EventListener这个标识接口.其整个处理过程是这样的,事...

收起
java监听事件
2022-05-21 13:42:22

事件监听器负责监听事件源发出的事件，事件监听器可以通过EventListener这个标识接口.，实现事件监听。如图：二.具体实现 2.1问题分析由于我们在实际开发中一个系统中是有很多联系的,当我们系统中的一个...

收起

后端 mysql

Java事件监听器的四种实现方式

JAVA事件监听器的四种实现方式

java事件监听

文章目录

前言

一、事件监听器

监听器的注册

事件处理的具体步骤

动作事件ActionEvent

二、适配器类

使用内部类来进行监听

鼠标事件

java事件监听器

1.动作事件监听器

2.键盘事件

3.鼠标事件

4.窗体事件

java事件监听模式实现万能事件总线.zip

Java事件监听的四种实现方式

java监听器的实现和原理详解

java事件监听机制.doc

Java 事件监听器

事件监听机制（一）Java事件监听

Java事件监听机制

java事件监听方法和代码

JAVA事件监听器

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

干货丨Java事件监听器的工作步骤介绍

java事件监听器原理

Java中的事件监听器

Java常用事件监听器与实例分析，java面试架构设计

java 事件监听（简单举例）

java 事件监听器ActionListener

Java实现一个简单的事件监听器

Java的事件监听器学习心得

java监听事件

java事件监听