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添加事件的⼏种⽅式（转载了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实现监听的四种⽅法详解实例代码直接上代码，⼤家可以参考下（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组件进行事件处理方法的分析与比较摘要：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代码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按钮监听机制）⼀、概念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设计模式——观察者模式（事件监听）最近在看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();}}嗯，写起来确实很简单，这是封装好的，我们只需要注册事件，并实现对应的事件响应就⾏了。

那么这种神奇的模式是怎么实现的呢？以下为我的分析过程。

低级事件与语义事件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 事件监听器使用小结（个人总结，有错请指）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中，可以将⼀个类定义在另⼀个类⾥⾯或者⼀个⽅法⾥⾯，这样的类称为内部类。

⼴泛意义上的内部类⼀般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。

下⾯就先来了解⼀下这四种内部类的⽤法。

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中的四种监听类⽤法在此列举四种⽅法：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();}}第⼆种，通过匿名类处理。

监听事件实现的四种⽅法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中的事件监听机制⿏标事件监听机制的三个⽅⾯：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 键盘事件接⼝，有释放，按下和敲击的事件处理⽅法了解了事件监听的这三个⽅⾯之后，我们要对组件添加事件的监听就很容易了。

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