java四种方法事件监听(匿名类,外部类,内部类,自身)
java事件监听器--java
产生事件 (ActionEvent) 用户操作 (单击按钮) 事件源 (Button) 注册 事件监听者 委托执行 事件监听程序 (执行ActionListener接口 actionPerformed方法)
JDK1.1的委托事件模型
为按钮注册事件监听程序
public void addActionListener(ActionListener handler)
单击按钮， 文本行中单击回车键， 双击列表框 选择菜单项时 文本行、文本区中修改内 容 选择复选框、选择框， 单击列表框， 选中带复选框的菜单项 鼠标 鼠标 单击鼠标时 鼠标进入 鼠标离开 按下鼠标时 放开鼠标时 按下键盘时 释放键盘时 获得焦点时 失去焦点时
textValueChanged(TextEvent e)
6.2.4 事件适配器
适配器类实现一个对应的所有接口，只是方法为空。 适配器类实现一个对应的所有接口，只是方法为空。
public abstract class WindowAdapter implements WindowListener { public void windowOpened(WindowEvent e) {} public void windowActivated(WindowEvent e) {} public void windowDeactivated(WindowEvent e) {} public void windowClosed(WindowEvent e) {} public void windowClosing(WindowEvent e) {} public void windowIconified(WindowEvent e) {} public void windowDeiconified(WindowEvent e) {} }
Java的监听器种类
Java的监听器种类网上整理！Listener是Servlet的监听器，它可以监听客户端的请求、服务端的操作等。
（通过监听器，可以自动激发一些操作，比如监听在线的用户的数量。
当增加一个HttpSession时，就激发 sessionCreated(HttpSessionEvent se)方法，这样就可以给在线人数加1。
）Servlet 监听器用于监听一些重要事件的发生，监听器对象在事情发生前、发生后可以做一些必要的处理。
目前 Servlet2.4 和 JSP2.0 常用的有7 个监听器接口，分为3 类：1. Servlet上下文进行监听（Application级）：用于监听 ServletContext 对象的创建和删除以及属性的添加、删除和修改等操作,该监听器需要用到如下两个接口类:(1) ServletContextAttributeListener：监听对 ServletContext 属性的操作,比如增加、删除、修改attributeAdded(ServletContextAttributeEvene) 添加属性时调用attributeReplaced(ServletContextAttributeEvente) 修改属性时调用attributeRemoved(ServletContextAttributeEvente) 删除属性时调用(2) ServletContextListener：监听对 ServletContext 对象的创建和删除contextInitialized(ServletContextEventsce) 初始化时调用contextDestroyed(ServletContextEvent sce) 销毁时调用,即当服务器重新加载时调用2. 监听HTTP会话（Session级）：用于监听 HTTP 会话活动情况和 HTTP 会话中的属性设置情况,也可以监听HTTP 会话的 active 和 passivate 情况等,该监听器需要用到如下多个接口类: (1) HttpSessionListener：监听 HttpSession 的操作sessionCreate(HttpSessionEvent se) 初始化时调用;sessionDestroyed(httpSessionEvent se) 销毁时调用,即当用户注销时调用Java代码1. package com.wl.listener.test;2.3.import javax.servlet.http.HttpSessionEvent;4.import javax.servlet.http.HttpSessionListener;5.6.public class HttpSessionListenerTest implements HttpSessionListener {7.8. public void sessionCreated(HttpSessionEvent arg0) {9.10. System.out.println("SSSSSSSSSSSSSSSSSS");11. }12.13. public void sessionDestroyed(HttpSessionEvent arg0) {14.15. System.out.println("EEEEEEEEEEEEEEEEEEE");16. }17.18.}在Web.xml的配置如下：Java代码1.<listener>2. <listener-class>com.wl.listener.test.HttpSessionListenerTest</listener-class>3. </listener>(2) HttpSessionActivationListener：用于监听 HTTP 会话的 active 和passivate 情况(3) HttpSessionAttributeListener：监听 HttpSession 中的属性操作attributeAdded(HttpSessionBindingEvent se) 添加属性时调用attributeRemoved(HttpSessionBindingEvent se) 删除属性时调用attributeReplaced(HttpSessionBindingEvent se) 修改属性时调用3. 对客户端请求进行监听（Requst级）：用于对客户端的请求进行监听是在 Servlet2.4 规范中新添加的一项新技术，使用的接口如下：(1) ServletRequestListener 接口类requestDestroyed(ServletRequestEvent e) 对销毁客户端进行监听,即当执行 request.removeAttribute("xxx") 时调用requestInitialized(ServletRequestEvent e) 对实现客户端的请求进行监听Java代码1.package com.wl.listener.test;2.3.import javax.servlet.ServletRequestEvent;4.import javax.servlet.ServletRequestListener;5.6.public class ServletRequestListenerTest implements ServletRequestListener {7.8. public void requestDestroyed(ServletRequestEvent arg0) {9.10. System.out.println("ServletRequestListenerTest is destroyed .......");11. }12.13. public void requestInitialized(ServletRequestEvent arg0) {14.15. System.out.println("ServletRequestListenerTest is start.......");16. }17.18.}在Web.xml中添加如下配置：Java代码1. <listener>2. <listener-class>com.wl.listener.test.ServletRequestListenerTest</listener-class>3.</listener>(2) ServletRequestAttributeListener 接口类attributeAdded(ServletRequestAttributeEvent e) 对属性添加进行监听attributeRemoved(ServletRequestAttributeEvent e) 对属性删除进行监听attributeReplaced(ServletRequestAttributeEvent e) 对属性替换进行监听。
Java添加事件监听的四种方法代码实例
Java添加事件监听的四种⽅法代码实例Java添加事件的⼏种⽅式（转载了codebrother的⽂章，做了稍微的改动）：/*** Java事件监听处理——⾃⾝类实现ActionListener接⼝，作为事件监听器** @author codebrother*/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("蓝⾊");btDialog = new JButton("弹窗");// 将按钮添加事件监听器btBlue.addActionListener(this);btDialog.addActionListener(this);add(btBlue);add(btDialog);setVisible(true);setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}// ***************************事件处理***************************@Overridepublic void actionPerformed(ActionEvent e) {if (e.getSource() == btBlue) {Container c = getContentPane();c.setBackground(Color.BLUE);}else if (e.getSource() == btDialog) {JDialog dialog = new JDialog();dialog.setBounds(300, 200, 400, 300);dialog.setVisible(true);}}}/*** Java事件监听处理——内部类处理** @author codebrother*/class EventListener3 extends JFrame {private JButton btBlue, btDialog;// 构造⽅法public EventListener3() {setTitle("Java GUI 事件监听处理");setBounds(100, 100, 500, 350);setLayout(new FlowLayout());btBlue = new JButton("蓝⾊");btDialog = new JButton("弹窗");// 添加事件监听器对象(⾯向对象思想)btBlue.addActionListener(new ColorEventListener());btDialog.addActionListener(new DialogEventListener());add(btBlue);add(btDialog);setVisible(true);setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}// 内部类ColorEventListener，实现ActionListener接⼝class ColorEventListener implements ActionListener {@Overridepublic void actionPerformed(ActionEvent e) {Container c = getContentPane();c.setBackground(Color.BLUE);}}// 内部类DialogEventListener，实现ActionListener接⼝ class DialogEventListener implements ActionListener { @Overridepublic void actionPerformed(ActionEvent e) {JDialog dialog = new JDialog();dialog.setBounds(300, 200, 400, 300);dialog.setVisible(true);}}}/*** Java事件监听处理——匿名内部类处理** @author codebrother*/class EventListener2 extends JFrame {private JButton btBlue, btDialog;public EventListener2() {setTitle("Java GUI 事件监听处理");setBounds(100, 100, 500, 350);setLayout(new FlowLayout());btBlue = new JButton("蓝⾊");btDialog = new JButton("弹窗");// 添加事件监听器(此处即为匿名类)btBlue.addActionListener(new ActionListener() {// 事件处理@Overridepublic void actionPerformed(ActionEvent e) {Container c = getContentPane();c.setBackground(Color.BLUE);}});// 并添加事件监听器btDialog.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {JDialog dialog = new JDialog();dialog.setBounds(300, 200, 400, 300);dialog.setVisible(true);}});add(btBlue);add(btDialog);setVisible(true);setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); }}/*** Java事件监听处理——外部类处理** @author codebrother*/class EventListener4 extends JFrame {private JButton btBlue, btDialog;public EventListener4() {setTitle("Java GUI 事件监听处理");setBounds(100, 100, 500, 350);setLayout(new FlowLayout());btBlue = new JButton("蓝⾊");btDialog = new JButton("弹窗");// 将按钮添加事件监听器btBlue.addActionListener(new ColorEventListener(this)); btDialog.addActionListener(new DialogEventListener());add(btBlue);add(btDialog);setVisible(true);setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); }}// 外部类ColorEventListener，实现ActionListener接⼝class ColorEventListener implements ActionListener {private EventListener4 el;ColorEventListener(EventListener4 el) {this.el = el;}@Overridepublic void actionPerformed(ActionEvent e) {Container c = el.getContentPane();c.setBackground(Color.BLUE);}}// 外部类DialogEventListener，实现ActionListener接⼝class DialogEventListener implements ActionListener { @Overridepublic void actionPerformed(ActionEvent e) {JDialog dialog = new JDialog();dialog.setBounds(300, 200, 400, 300);dialog.setVisible(true);}}public class ActionListenerTest{public static void main(String args[]){new EventListener2();}}。
Android实现监听的四种方法详解实例代码
Android实现监听的四种⽅法详解实例代码直接上代码，⼤家可以参考下（1）⾃⾝类作为事件监听器package .gdmec.s0*******.work5;import android.support.v7.app.AppCompatActivity;import android.os.Bundle;import android.view.View;import android.widget.Button;import android.widget.Toast;public class MainActivity extends AppCompatActivity implements View.OnClickListener{@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_main);Button btn1 = (Button) findViewById(R.id.btn1);btn1.setText("单击");btn1.setOnClickListener(this);}@Overridepublic void onClick(View v) {Toast.makeText(this,"已单击我...",Toast.LENGTH_SHORT).show();System.out.println("已单击我...");}}（2）外部类作为事件监听器：package .gdmec.s0*******.work5;import android.support.v7.app.AppCompatActivity;import android.os.Bundle;import android.view.View;import android.widget.Button;public class Act2 extends AppCompatActivity {@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_act2);Button btn2 = (Button) findViewById(R.id.btn2);btn2.setText("单击");btn2.setOnClickListener(new OuterClass("已单击我..."));}}class OuterClass implements View.OnClickListener{private String str="已单击我....";public OuterClass(String str){super();this.str=str;}@Overridepublic void onClick(View v) {System.out.println(str);}}（3）内部类作为事件监听器：package .gdmec.s0*******.work5;import android.support.v7.app.AppCompatActivity;import android.os.Bundle;import android.view.View;import android.widget.Button;import android.widget.Toast;public class Act3 extends AppCompatActivity {@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_act3);Button btn3 = (Button) findViewById(R.id.btn3);btn3.setText("单击");btn3.setOnClickListener(new OuterClass());}class OuterClass implements View.OnClickListener{@Overridepublic void onClick(View v) {Toast.makeText(Act3.this,"已单击我...",Toast.LENGTH_SHORT).show();System.out.println("已单击我...");}}}（4）匿名类作为事件监听器：package .gdmec.s0*******.work5;import android.support.v7.app.AppCompatActivity;import android.os.Bundle;import android.view.View;import android.widget.Button;import android.widget.Toast;public class Act4 extends AppCompatActivity {@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_act4);Button btn4 = (Button) findViewById(R.id.btn4);btn4.setText("单击");btn4.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {Toast.makeText(Act4.this,"已单击我...",Toast.LENGTH_SHORT).show();System.out.println("已单击我...");}});}}以上四种⽅法之后，在xml⽂件中给每⼀个事件即activity⾥⾯定义多⼀个android label即可。
使用Java Swing组件进行事件处理方法的分析与比较
使用Java Swing组件进行事件处理方法的分析与比较摘要：Swing组件是Java基本类库的一部分，是用于开发Java应用程序用户界面的开发工具包。
通过具体实例分析了多种使用Swing 组件进行事件处理的方法，并对这些方法进行了比较。
关键词：Java；Swing；监听；内部类；事件0引言Swing组件是Java语言中用来编写图形化界面的工具包，它使用灵活、功能强大，使得开发人员利用其提供的各种类与方法能够快速地创建出符合用户需求的各种美观、实用的图形界面。
Swing组件具有自动对各种用户的动作产生响应的功能，例如当某一用户点击button按钮或选择菜单栏时，该动作将会被监听处理。
在代码编写的过程中注册监听器是必须完成的工作，通过它对事件源进行监听，这样在程序中就可以十分方便地对用户行为进行响应处理。
1使用Swing组件进行事件处理过程使用Java Swing组件进行事件处理的过程分为如下几个步骤：首先，创建一个新的Swing组件（例如按钮或者菜单栏等）；其次，将刚刚创建的组件添加到定义的面板中去；然后，通过注册监听器对事件源进行监听（例如对用户点击按钮或者点击鼠标的动作）；最后，在程序中编写响应事件源产生事件的各种方法。
上述几个步骤的实现可以通过多种方法来完成。
第一种可使用的方法是通过注册单个监听器并使用多个if条件判断语句来决定响应的事件源；第二种方法使用Java语言中的匿名内部类来进行相关的事件处理过程；第三种方法是通过一般内部类来进行事件的响应。
第二种、第三种方法从本质上来说，都是在进行事件处理的过程中使用了多个Java的内部类，而不同之处在于具体实现有较大变化。
下面通过一个简单的Java 应用程序（创建两个按钮，当用户点击按钮后产生不同的显示结果）展示怎样通过以上3种方法来实现Swing组件的事件处理过程。
1.1单个监听器方式该方法使用单个监听器来进行实现。
具体完成该方法的过程为：建立一个名为Example的类，当用户点击button按钮后，监听器ExampleListenner会对该动作进行监听并交由actionPerformed（）方法来进行相应的事件处理。
Java事件处理机制-+事件监听器的四种实现方式+
Java事件处理机制- 事件监听器的四种实现方式⏹自身类作为事件监听器⏹外部类作为事件监听器⏹匿名内部类作为事件监听器⏹内部类作为事件监听器自身类作为事件监听器:Java代码import javax.swing.*;import java.awt.*;import java.awt.event.*;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.*;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.*;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.*;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();}}。
java监听机制模拟（JButton按钮监听机制）
java监听机制模拟（JButton按钮监听机制）⼀、概念1.事件监听器事件监听器就我个⼈的理解就是：被外部事件（键盘、⿏标）引发的程序，这段程序是被嵌⼊到事件源的类⾥⾯，它负责监听事件列表。
⽽很多⼈把事件监听器理解成是实现EventListener接⼝的类。
⽽我的理解是实现EventListener接⼝的类是事件处理器。
⾥边有处理事件的⽅法。
从逻辑上看是这样的，但是⼈家既然这样来命名了，那也没有办法。
因为程序员只要知道这么去添加监听器就⾏了，不必理解内部的处理流程，但是作为⼀个热爱计算机的程序员来说，必须要理解其过程。
事件监听器的功能：负责监听事件注册类表，有相关事件注册就⽴马 new ⼀个事件，然后调⽤事件处理器⾥的事件处理⽅法，完成事件处理。
然后移除事件注册列表的相关事件。
2.事件源：事件源是事件的起源，可以称作事件触发源。
其主要的功能是，介绍外边事件，⽐如键盘、⿏标等，当有事件时就会触发事件监听器。
主成分：主要由事件监听器、注册事件⽅法（如：addActionListener）构成。
3.事件对象：实现EventObject接⼝的类。
⾥⾯封装了对事件源进⾏操作的⽅法。
⽐如：getActionCommand()⽅法。
4.事件处理器事件处理器是对事件进⾏处理的类，这类实现EventListener接⼝。
此类由程序员编写。
⽐如事件处理器中的处理程序：⼆、模拟程序以JButton按钮为列，看⼀下程序：import java.util.EventListener;import java.util.EventObject;import java.util.Vector;//⾃定义⼀个按钮事件class ActionEvent extends EventObject{String actionCommand;public ActionEvent(Object source,String command){super(source);this.actionCommand = command;System.out.println("按钮点击事件产⽣！");}public String getActionCommand() {return actionCommand;}}// 弄⼀个在按钮⾥⾯使⽤的接⼝,通过继承此接⼝可以完成事件处理的类interface ActionListener extends EventListener{//这⾥是当事件发⽣后的响应过程public void actionPerformed(ActionEvent me);}//再⾃定义⼀个监听器class MyListener implements ActionListener{//这⾥是当事件发⽣后的响应过程public void actionPerformed(ActionEvent me){{String str=me.getActionCommand();if(str.equals("hello"))System.out.println("按钮点击事件被处理");}}//以下这个类为触发事件的事件源class JButton { //⽐如button按钮String s;JButton(String s){this.s=s;}String getAt(){return s;}private Vector vectorListeners=new Vector(); //定义⼀个向量public synchronized void addActionListener(ActionListener actionlistener) //注册监听器{vectorListeners.addElement(actionlistener); // 将指定元素添加到此向量的末尾System.out.println("按钮上注册监听器");}public synchronized void removeActionListener(ActionListener actionlistener) //移除监听器{vectorListeners.removeElement(actionlistener); //从此向量中移除变量的第⼀个（索引最⼩的）匹配项。
Java设计模式——观察者模式（事件监听）
Java设计模式——观察者模式（事件监听）最近在看Tomcat和Spring的源码，在启动的时候注册了各种Listener，事件触发的时候就执⾏，这⾥就⽤到了设计模式中的观察者模式。
引-GUI中的事件监听想想以前在学Java的GUI编程的时候，就⽤到了事件的注册监听，然后写了⼀个⼩程序试验⼀下：点击按钮触发相应的事件public class ButtonTest extends JFrame {ButtonTest() {JPanel panel = new JPanel();JButton button1 = new JButton("按钮⼀");JButton button2 = new JButton("按钮⼆");panel.add(button1);panel.add(button2);this.getContentPane().add(panel);this.setVisible(true);button1.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {System.out.println("你按了按钮⼀");}});button2.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {System.out.println("你按了按钮⼆");}});}public static void main(String args[]) {new ButtonTest();}}嗯，写起来确实很简单，这是封装好的，我们只需要注册事件，并实现对应的事件响应就⾏了。
那么这种神奇的模式是怎么实现的呢？以下为我的分析过程。
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;
监听器的四种监听方法
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事件类型
低级事件与语义事件AWT 提供了二种概念性事件类型：低级事件和语义事件。
低级事件代表屏幕上可视化组件的低级输入或窗口系统事件。
AWT 定义的低级事件类如下：java.util.EventObjectjava.awt.AWTEventponentEvent（组件改变大小，移动等）java.awt.event.FocusEvent（组件获得焦点，失去焦点）java.awt.event.InputEventjava.awt.event.KeyEvent（组件获得键按下、键释放等）java.awt.event.MouseEvent（组件获得鼠标按下、鼠标移动等）java.awt.event.ContainerEventjava.awt.event.WindowEvent语义事件是在较高层次定义的，用于封装用户接口组件模型的语义。
AWT 定义的语义事件类如下：java.util.EventObjectjava.awt.AWTEventjava.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 中的特定方法合起来定义。
java事件监听器使用小结(个人总结,有错请指)
本文由我司收集整编，推荐下载，如有疑问，请与我司联系java 事件监听器使用小结（个人总结，有错请指）2014/02/14 1643 //第一种:外部定义，通过监听器的对象来调用的监听器import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.*; //定义监听器class MyListener implements ActionListener{ public voidactionPerformed(ActionEvent e) { JOptionPane.showMessageDialog(null,”按钮被点击”);//弹出消息对话框} }//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////public class TestListener{ //主方法public static void main(String[]args){ //创建图形界面JFrame frame=newJFrame(“监听器的用法”); frame.setSize(400, 300); frame.setLocationRelativeTo(null);//null 即为空，框架在屏幕中居中显示frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); JPanel panel=new JPanel(); frame.add(panel); JButton jbt=newJButton(“按钮”);panel.add(jbt); MyListener mylistener = newMyListener(); jbt.addActionListener(mylistener); }}============================================================================================================================================================================================//第二种：内部定义调用的监听器（匿名内部类作为事件监听器）import java.awt.event.ActionEvent;import java.awt.event.ActionListener;importjavax.swing.*;/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////public class TestListener{ //主方法public static void main(String[]args){ //创建图形界面JFrame frame=newJFrame(“监听器的用法”);frame.setSize(400, 300); frame.setLocationRelativeTo(null);//null 即为空，框架在屏幕中居中显示frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); JPanel panel=new JPanel(); frame.add(panel); JButton jbt=newJButton(“按钮”);。
Java内部类详解--成员内部类，局部内部类，匿名内部类，静态内部类
Java内部类详解--成员内部类，局部内部类，匿名内部类，静态内部类说起内部类这个词，想必很多⼈都不陌⽣，但是⼜会觉得不熟悉。
原因是平时编写代码时可能⽤到的场景不多，⽤得最多的是在有事件监听的情况下，并且即使⽤到也很少去总结内部类的⽤法。
今天我们就来⼀探究竟。
下⾯是本⽂的⽬录⼤纲： ⼀.内部类基础 ⼆.深⼊理解内部类 三.内部类的使⽤场景和好处 四.常见的与内部类相关的笔试⾯试题 若有不正之处，请多谅解并欢迎批评指正。
请尊重作者劳动成果，转载请标明原⽂链接：⼀.内部类基础 在Java中，可以将⼀个类定义在另⼀个类⾥⾯或者⼀个⽅法⾥⾯，这样的类称为内部类。
⼴泛意义上的内部类⼀般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。
下⾯就先来了解⼀下这四种内部类的⽤法。
1.成员内部类 成员内部类是最普通的内部类，它的定义为位于另⼀个类的内部，形如下⾯的形式：1 2 3 4 5 6 7 8 9 10 11 12 13class Circle {double radius = 0;public Circle(double radius) {this.radius = radius;}class Draw { //内部类public void drawSahpe() {System.out.println("drawshape"); }}} 这样看起来，类Draw像是类Circle的⼀个成员，Circle称为外部类。
成员内部类可以⽆条件访问外部类的所有成员属性和成员⽅法（包括private成员和静态成员）。
1 2 3 4 5 6 7 8 9 10 11 12 13 14class Circle {private double radius = 0;public static int count =1;public Circle(double radius) {this.radius = radius;}class Draw { //内部类public void drawSahpe() {System.out.println(radius); //外部类的private成员 System.out.println(count); //外部类的静态成员 }}} 不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者⽅法时，会发⽣隐藏现象，即默认情况下访问的是成员内部类的成员。
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 事件类和事件监听器
TextEvent
TextListener
textValueChanged(TextValue)
ComponentEvent
ComponentListener
componentMoved(ComponentEvent)
componentHidded(ComponentEvent)
AdjustmentEvent调整事件，发生于用户在滚动条上移动滑块时。
ItemEvent项目事件，发生于用户从一组选择框或者列表框中进行选择时。
TextEvent文本事件，发生于文本框或者文本域中的内容发生改变时。
事件与事件源相对应，“事件类”与一个监听器的方法对应，也与监听器的接口相对应，其核心是事件类。例如，对Button按钮操作时，可能发生ActionEvent，这就需要使用addActionListener()；对多行文本域TextArea，产生TextEvent，则需要使用addTextListener(this)。
AWT组件类注册和取消监听器注册的方法如下。
注册监听器EventSource.addxxxListener(EventListener)
取消监听器EventSource.removexxxListener(EventListener)
在AWT中，所有AWT事件都有其相应的监听器接口，每个接口中分别有一个或多个处理事件的方法。如表10-1所示。
componentResized(ComponentEvent)
componentShown(ComponentEvent)
ContainerEvent
ContainerListener
监听事件实现的四种方法
监听事件实现的四种⽅法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中的事件监听机制⿏标事件监听机制的三个⽅⾯：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事件监听机制
{
super(source);
obj = source;
}
public Object getSource()
{
return obj;
}
public void say()
{
System.out.println("This is say method...");
}
}
（2）定义新的事件监听接口，该接口继承自EventListener；该接口包含对DemeEvent事件的处理程序：
DemoEvent.java
package demo.listener;
import java.util.EventObject;
public class DemoEvent extends EventObject
{
Object obj;
public DemoEvent(Object source)
其实自定义事件在java中很有用处，我们有的时候想让自己的程序产生一个事件，但有不希望（或者不可能）用鼠标，键盘之类的输入设备进行操作，比如你写一个应用程序，在这个程序中一旦收到邮件就对邮件进行相关处理，对于“收到邮件”这个事件，jdk中就没有定义。对于这样的事件，以及对于这样的事件的监听器，我们只能自己动手完成了。
使用匿名内部类处理事件监听.
案例：鼠标运动
匿名类的方式进行事件处理
public class MouseMotionDemo extends JFrame { …… //声明窗体中的组件，代码略 public MouseMotionDemo() { //构造方法，代码略 …… /*将事件源注册到监听器，监听器用匿名类实现*/ this.addMouseMotionListener(new MouseMotionListener() { //实现MouseMotionListener接口中的鼠标移动方法，代码略 public void mouseMoved(MouseEvent me) { …… } //实现MouseMotionListener接口中的鼠标拖动方法，代码略 public void mouseDragged(MouseEvent me) { …… } }); …… } public static void main(String[] args) { …… } }
匿名内部类处理事件监听Fra bibliotek名内部类匿名类其实就是一种比较特殊的内部类，只是这个类没有 名字而已； 匿名类与内部类相似，能够访问到外部类中的所有成员； 很多情况下（特别是在事件处理中），匿名类一般被定义 在外部类的某个方法中，所以也被称为局部内部类，对于 局部内部类，它还可以访问到这个方法的参数； 在适当的情况下，使用匿名类来实现事件处理，会使代码 更简洁，更灵活。 只能使用一次。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
JAVA四种方法实现事件监听1.外部类实现事件监听：import java.awt.*;import java.awt.event.*;import javax.swing.*;publicclass Listener1extends JFrame {JButton button1,button2;JPanel pane1,pane2,p1,p2;CardLayout card1=new CardLayout();/*CardLayout布局方式将容器中的每个组件看作一张卡片。
一次只能看到一张卡片，容器则充当卡片的堆栈*/Listener1(){this.setTitle("外部类实现事件监听");this.setBounds(200,200,300,200);this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);this.setVisible(true);init();}publicvoid init(){p1=new JPanel();p1.add(new JLabel("第一个面板"));p1.setBackground(Color.red);p2=new JPanel();p2.add(new JLabel("第二个面板"));p2.setBackground(Color.green);pane1=new JPanel(card1);pane1.add("红色", p1);pane1.add("绿色", p2);button1=new JButton("红色");button2=new JButton("绿色");pane2=new JPanel();pane2.add(button1);pane2.add(button2);this.add(pane1,BorderLayout.CENTER);this.add(pane2,BorderLayout.SOUTH);button1.addActionListener(new ColorEvent(card1,pane1));button2.addActionListener(new ColorEvent(card1,pane1)); }publicstaticvoid main(String[] args) {// TODO Auto-generated method stubnew Listener1();}}class ColorEvent implements ActionListener{CardLayout card1=new CardLayout();JPanel pane1=new JPanel();ColorEvent(CardLayout card1,JPanel pane1){this.card1=card1;this.pane1=pane1;}@Overridepublicvoid actionPerformed(ActionEvent e) {// TODO Auto-generated method stubif(e.getActionCommand().equals("红色")){//getActionCommand()返回与此动作相关的命令字符串card1.show(pane1, "红色");}elseif(e.getActionCommand().equals("绿色")){card1.show(pane1, "绿色");}}}2.内部类实现事件监听：import java.awt.*;import java.awt.event.*;import javax.swing.*;publicclass Listener2extends JFrame {JButton button1,button2;JPanel pane1,pane2,p1,p2;CardLayout card1=new CardLayout();/*CardLayout布局方式将容器中的每个组件看作一张卡片。
一次只能看到一张卡片，容器则充当卡片的堆栈*/Listener2(){this.setTitle("内部类实现事件监听");this.setBounds(200,200,300,200);this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);this.setVisible(true);init();}publicvoid init(){p1=new JPanel();p1.add(new JLabel("第一个面板"));p1.setBackground(Color.red);p2=new JPanel();p2.add(new JLabel("第二个面板"));p2.setBackground(Color.green);pane1=new JPanel(card1);pane1.add("红色", p1);pane1.add("绿色", p2);button1=new JButton("红色");button2=new JButton("绿色");pane2=new JPanel();pane2.add(button1);pane2.add(button2);this.add(pane1,BorderLayout.CENTER);this.add(pane2,BorderLayout.SOUTH);button1.addActionListener(new ColorEvent());button2.addActionListener(new ColorEvent()); }class ColorEvent implements ActionListener{@Overridepublicvoid actionPerformed(ActionEvent e) { // TODO Auto-generated method stubif(e.getSource()==button1){//返回发生事件的对象。
card1.show(pane1, "红色");}elseif(e.getSource()==button2){card1.show(pane1, "绿色");}}}publicstaticvoid main(String[] args) {// TODO Auto-generated method stubnew Listener2();}}3.自身类实现事件监听：import java.awt.*;import java.awt.event.*;import javax.swing.*;publicclass Listener3extends JFrame implements ActionListener { JButton button1,button2;JPanel pane1,pane2,p1,p2;CardLayout card1=new CardLayout();/*CardLayout布局方式将容器中的每个组件看作一张卡片。
一次只能看到一张卡片，容器则充当卡片的堆栈*/Listener3(){this.setTitle("自身类实现事件监听");this.setBounds(200,200,300,200);this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);this.setVisible(true);init();}publicvoid init(){p1=new JPanel();p1.add(new JLabel("第一个面板"));p1.setBackground(Color.red);p2=new JPanel();p2.add(new JLabel("第二个面板"));p2.setBackground(Color.green);pane1=new JPanel(card1);pane1.add("红色", p1);pane1.add("绿色", p2);button1=new JButton("红色");button2=new JButton("绿色");pane2=new JPanel();pane2.add(button1);pane2.add(button2);this.add(pane1,BorderLayout.CENTER);this.add(pane2,BorderLayout.SOUTH);button1.addActionListener(this);button2.addActionListener(this);}@Overridepublicvoid actionPerformed(ActionEvent e) {// TODO Auto-generated method stubif(e.getActionCommand().equals("红色")){//getActionCommand()返回与此动作相关的命令字符串card1.show(pane1, "红色");}elseif(e.getActionCommand().equals("绿色")){card1.show(pane1, "绿色");}}publicstaticvoid main(String[] args) {// TODO Auto-generated method stubnew Listener3();}}4.匿名类实现事件监听：import java.awt.*;import java.awt.event.*;import javax.swing.*;publicclass Listener4extends JFrame{JButton button1,button2;JPanel pane1,pane2,p1,p2;CardLayout card1=new CardLayout();/*CardLayout布局方式将容器中的每个组件看作一张卡片。