java中按钮监听以及鼠标监听的使用 - 陈强 - ITeye技术网站
博客分类：
我们在进行的开发的时候，按钮以及鼠标监听的使用无疑是相当最要的，而如何巧妙的运用这些监听器，对今后的开发更是有很大的帮助，下面将分别介绍。
实现按钮监听的方法：
在下面有一个的类，它是一个用于接收操作事件的侦听器接口，对处理操作事件感兴趣的就可以去使用这个接口。
首先我们需要写一个类去实现这个接口，然后对我们的对象添加按钮响应，最后再给这个按钮添加监听器，具体代码如下：
JButton bu=new JButton("按钮");
bu.setActionCommand("press");//设置按钮响应
bu.addActionListener(listener);//添加按钮监听
import java.awt.event.ActionE
import java.awt.event.ActionL
publicclass MyActionListener implements ActionListener{
publicvoid actionPerformed(ActionEvent e){
String com=e.getActionCommand();//得到按钮响应
if(com.equals("press")){
System.out.println("点击了");
当然，可以通过匿名内部类的方法来给按钮添加监听，这里就不再详细介绍了，需要注意的是，每个按钮都可以通过设置独立的按钮响应来实现不同按钮之间的功能。是不是很方便呢？
讲完了按钮响应，接下来就来介绍一下鼠标响应，我们可以在窗体上通过鼠标实现各种功能，如画图板，五子棋，鼠标游戏等等，这是GUI中一个非常重要的点，学好了这个对今后的各种应用开发都有极大的帮助。
废话不多说，下面就来做一做吧：
首先，实现鼠标监听有两种方法，一是实现java.awt.MouseListener类，这是一个用于接收组件上感兴趣的鼠标事件（按下、释放、单击、进入或离开）的侦听器接口，同样要用上面的实现方法，具体如下：
import java.awt.event.MouseE
import java.awt.event.MouseL
publicclass MyMouseListener implements MouseListener{
//鼠标点击事件
publicvoid mouseClicked(MouseEvent e){
System.out.println("mouseClicked");
//鼠标按下事件
publicvoid mousePressed(MouseEvent e){
System.out.println("mousePressed");
//鼠标释放事件
publicvoid mouseReleased(MouseEvent e){
System.out.println("mouseReleased");
//鼠标进入事件
publicvoid mouseEntered(MouseEvent e){
System.out.println("mouseEntered");
//鼠标离开事件
publicvoid mouseExited(MouseEvent e){
System.out.println("mouseExited");
当然，这个时候我们是要向窗体添加监听，所以应该对窗体使用addMouseListener()的方法，不过这个方法代码太过于冗长，而且其中的一些方法并不是我们每次都会用上，那么下面还有一种方法，是通过实现MouseAdapter类来实现的，这是一个抽象类，可以通过其他类继承它来实现，我们可以查看他的源码：
public abstract class MouseAdapter implements MouseListener, MouseWheelListener, MouseMotionListener
我们发现，这个抽象类实现了三个接口，MouseListener,MouseWheelListener以及MouseMotionListener,所以这个抽象类也就实现了这三个类中的所有方法，而且在使用的时候，我们可以只写出自己需要使用的方法，是不是感觉更加灵活呢？具体的使用，我会在简易画图板的制作中提到，大家不妨试一下吧。
浏览: 100542 次
来自: 长沙
敢问兄台，size()是咩。&code& if(i ...
加油！你比我好多了，我每天都在敲着不想敲的代码
加油！其实北京没那么难，习惯了就好，
看着好沉重的感觉 其实没啥的 等你有一天进入所谓你的梦想公司了 ...
just do IT。当年就是听到这句话才干上IT的。java Event机制 、 observer设计模式 -
- ITeye技术网站
博客分类：
研究了一下java Event机制 和observer设计模式，发现两者都者不多，一样的原因
java Event机制不过是observer设计模式的一个特例。
一 、observer设计模式
public class MyData {
public MyData(String name, int age) {
this.username =
this.age =
public String getUsername() {
public void setUsername(String username) {
this.username =
public int getAge() {
public void setAge(int age) {
this.age =
EventSource:
public class MyListener {
public void onMyEvent(MyEvent event) {
System.out.println(" event data . name
is : "+ event.getSource().getUsername());
public class MyEvent{
private MyD
public MyEvent(MyData source) {
this.setSource(source);
public MyData getSource() {
public void setSource(MyData source) {
this.source =
private static final long serialVersionUID = 1L;
Listener：
public class MyListener {
public void onMyEvent(MyEvent event) {
System.out.println(" event data . name
is : "+ event.getSource().getUsername());
public class TestEvent {
* @param args
public static void main(String[] args) {
EventSource es = new EventSource();
MyData customData = new MyData("Robert",27);
MyEvent eo = new MyEvent(customData);
MyListener cl = new MyListener();
es.addEventListener(cl);
es.changeSource(eo);
对于observer设计模式，我们大致要建立4个类：
MyData类用来存放数据
MyEvent类用来表示事件
EventSource类用来表示事件源
MyListener类用来表示事件监听器
EventSource相对复杂一点，其他类都是很简单的。当然，我们也可以把逻辑处理搬到其他地方去，不过那样的花，这个恐怕就不是observer设计模式了吧！
理解之后发现原理十分简单，只是一个小小track而已！
二 、java提供的Event机制
如果是java的事件机制，原理也差不多，但是，jdk就已经提供了一些类了：
EventObject 事件对象，包含事件对应的数据，需要自定义类继承拓展它
EventListener事件监听器，需要自定义类继承拓展它
—— 不，这只是sun的建议，其实我们完全可以不考虑EventObject、EventListener。EventListener只是一个标记接口。EventObject 也只是维护了一个source的变量，提供 getSource方法。几乎没什么用
Observeable
—— 这两个类才是重要的 Observeable提供一系列很用的方法、Observer也有一个重要的update方法
（当然，其他类还是需要自己编写）
——所以不用这么多的自定义类了——虽然方便，但是可能不是那么灵活...
参考了几篇blog，发现：
写的啰嗦，甚至可以说是一种错误的写法；
/blog/775395也稍显复杂。
我自己写了个简单实现：
package com.test.
* 可以看做业务po，业务逻辑的处理应该在此类中完成
* 需要继承Observable是因为我们用到了java提供的功能
public class EventObserveable extends java.util.Observable{
public void action(Object arg) {
super.setChanged();// setChanged 是protected方法，必须由本来来调用。。。
super.notifyObservers(arg);
public void logicHandler(String name) {
// ... logic handle here , like :
System.out.println("Object arg is :" + name);
package com.test.
import java.util.O
import java.util.O
* 观察者， 此update方法自动由Observer类调用，
* 而 update方法主要是调用 业务方法， 当然，我们也可以在这个方法中直接的业务逻辑处理， 而不用调来调去
* 需要继承Observer是因为 它是和Observable配套使用的
public class EventObserver implements Observer {
public void update(Observable o, Object arg) {
((EventObserveable)o).logicHandler(arg.toString());
//System.out.println("Object arg is :" + arg);
package com.test.
import java.util.O
* 此类可以 看做 事件源， 因为notifyEvent 就是发送事件的源头 EXACTLY! 专供外部调用， 同时 notifyEvent 也是事件处理回调函数
此类中，我们需要保持一个Observeable的对象，它来代替我们一部分工作
当然，首先要 完成 监听器的 添加、移除 等监听器相关操作
———— 当然，我们可以有其他方式添加监听器(参：/blog/775395)，但是把addEventListener放在这个累里面感觉比较直接
此类只是简单实现，实际中我们需要完善其功能，可以写的很复杂 ！
public class EventSource {
private EventObserveable ob = new EventObserveable();
public void addEventListener(Observer listener) {
ob.addObserver(listener);
public void removeEventListener(Observer listener) {
ob.deleteObserver(listener);
public void notifyEvent(Object arg) {
ob.action(arg);
package com.test.
public class Test {
* @param args
public static void main(String[] args) {
EventSource ds = new EventSource();
ds.addEventListener(new EventObserver());
ds.notifyEvent("Hello LuK ! ");
总共4个类，个个简单。
总结： 看再多的设计模式的书或blog或面试宝典都没用，如果自己不去code不去花时间领会的话；当然如果自己没基础，code了后可能还是不明白。。
浏览: 63988 次
来自: 广州
博主，在么？
好的， 不过最近不太看那个了。。。
不错。你不是一个人在战斗。我最近也在看源码。刚开始看懂了一些很 ...怎么判断事件有没有被触发了_java吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：553,595贴子：
怎么判断事件有没有被触发了收藏
是这样的，我在一个类里调用另一个类的构造方法,在构造方法里构造了一个Frame,Frame里添加了Button按钮 以及Button按钮的监听事件，但是如果不按那个按钮,调用的那个类下面的函数也会运行下去，这样我的程序就出错了，我是想如果不按那个按钮,程序就不运行下去
千锋java,Java+大数据全项目实训,两周免费试听,0基础小班授课!千锋java零学费学习,Java+大数据培训,先入学后付款
爪无力[发自WindowsPhone客户端-百度贴吧]
调用的那个类的方法 调用的位置放在按钮的监听里面
登录百度帐号推荐应用
为兴趣而生，贴吧更懂你。或Java图形界面事件监听处理之四种方法
我自2009年上大学开始学习Java，由于JavaSE的GUI编程不是很占优势，因而也没有重视过，尤其是事件监听处理。综合看过很多Java讲师的视频，以及网上相关资料，特综合一下，望对大家有帮助，尤其是Java事件编程初学者，愿大家看后不再犹豫用哪种方法而发愁。
大家先看看简单的应用程序截图，考虑一下如何实现。
截图如图一、图二、图三
图一 初始界面截图
图二 蓝色按钮事件处理
图三 弹窗按钮事件处理
在此列举四种方法：
自身类实现ActionListener接口，作为事件监听器
通过匿名类处理
通过内部类处理
通过外部类处理
下面依次介绍：
第一种：自身类实现ActionListener接口，作为事件监听器。
这种方法是最基本的，也是初学者经常使用的，我当初即是如此。
import java.awt.C
import java.awt.C
import java.awt.FlowL
import java.awt.event.ActionE
java.awt.event.ActionL
import javax.swing.JB
import javax.swing.JD
import javax.swing.JF
public class EventListener1 extends JFrame
implements ActionListener {
private JButton btBlue, btD
// 构造方法
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);
***************************事件处理***************************
public 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,
dialog.setVisible(true);
***************************主方法***************************
public static void main(String[] args)
new EventListener1();
第二种，通过匿名类处理。
这是比较好的一种方法，我是在2011年开始使用这种方法的。
import java.awt.C
import java.awt.C
import java.awt.FlowL
import java.awt.event.ActionE
java.awt.event.ActionL
import javax.swing.JB
import javax.swing.JD
import javax.swing.JF
public class EventListener2 extends JFrame
private JButton btBlue, btD
// 构造方法
public EventListener2() {
// 设置标题栏内容
setTitle("Java GUI 事件监听处理");
// 设置初始化窗口位置
setBounds(100, 100, 500, 350);
// 设置窗口布局
setLayout(new FlowLayout());
// 创建按钮对象
btBlue = new JButton("蓝色");
// 添加事件监听器(此处即为匿名类)
btBlue.addActionListener(new ActionListener()
// 事件处理
public void actionPerformed(ActionEvent e)
// 获得容器，设置容器背景颜色
Container c = getContentPane();
c.setBackground(Color.BLUE);
// 创建按钮对象,并添加事件监听器
btDialog = new JButton("弹窗");
btDialog.addActionListener(new
ActionListener() {
// 事件处理
public void actionPerformed(ActionEvent e)
// 创建JDialog窗口对象
JDialog dialog = new JDialog();
dialog.setBounds(300, 200, 400,
dialog.setVisible(true);
// 把按钮容器添加到JFrame容器上
add(btBlue);
add(btDialog);
// 设置窗口可视化
setVisible(true);
// 设置窗口关闭
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
***************************主方法***************************
public static void main(String[] args)
new EventListener2();
第三种：通过内部类处理。
该种方法更符合面向对象编程的思想。
import java.awt.C
import java.awt.C
import java.awt.FlowL
import java.awt.event.ActionE
java.awt.event.ActionL
import javax.swing.JB
import javax.swing.JD
import javax.swing.JF
public class EventListener3 extends JFrame
private JButton btBlue, btD
// 构造方法
public EventListener3() {
// 设置标题栏内容
setTitle("Java GUI 事件监听处理");
// 设置初始化窗口位置
setBounds(100, 100, 500, 350);
// 设置窗口布局
setLayout(new FlowLayout());
// 创建按钮对象
btBlue = new JButton("蓝色");
// 添加事件监听器对象(面向对象思想)
btBlue.addActionListener(new
ColorEventListener());
btDialog = new JButton("弹窗");
btDialog.addActionListener(new
DialogEventListener());
// 把按钮容器添加到JFrame容器上
add(btBlue);
add(btDialog);
// 设置窗口可视化
setVisible(true);
// 设置窗口关闭
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
内部类ColorEventListener，实现ActionListener接口
class ColorEventListener implements
ActionListener {
public void actionPerformed(ActionEvent e)
Container c = getContentPane();
c.setBackground(Color.BLUE);
内部类DialogEventListener，实现ActionListener接口
class DialogEventListener implements
ActionListener {
public void actionPerformed(ActionEvent e)
// 创建JDialog窗口对象
JDialog dialog = new JDialog();
dialog.setBounds(300, 200, 400,
dialog.setVisible(true);
***************************主方法***************************
public static void main(String[] args)
new EventListener3();
第四种：通过外部类处理
这种我个人不常用。
import java.awt.C
import java.awt.C
import java.awt.FlowL
import java.awt.event.ActionE
java.awt.event.ActionL
import javax.swing.JB
import javax.swing.JD
import javax.swing.JF
public class EventListener4 extends JFrame
private JButton btBlue, btD
// 构造方法
public EventListener4() {
// 设置标题栏内容
setTitle("Java GUI 事件监听处理");
// 设置初始化窗口位置
setBounds(100, 100, 500, 350);
// 设置窗口布局
setLayout(new FlowLayout());
// 创建按钮对象
btBlue = new JButton("蓝色");
// 将按钮添加事件监听器
btBlue.addActionListener(new
ColorEventListener(this));
// 创建按钮对象
btDialog = new JButton("弹窗");
// 将按钮添加事件监听器
btDialog.addActionListener(new
DialogEventListener());
// 把按钮容器添加到JFrame容器上
add(btBlue);
add(btDialog);
// 设置窗口可视化
setVisible(true);
// 设置窗口关闭
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
***************************主方法***************************
public static void main(String[] args)
new EventListener4();
外部类ColorEventListener，实现ActionListener接口
class ColorEventListener implements
ActionListener {
private EventListener4
ColorEventListener(EventListener4 el)
public void actionPerformed(ActionEvent e)
Container c = el.getContentPane();
c.setBackground(Color.BLUE);
外部类DialogEventListener，实现ActionListener接口
class DialogEventListener implements
ActionListener {
public void actionPerformed(ActionEvent e)
// 创建JDialog窗口对象
JDialog dialog = new JDialog();
dialog.setBounds(300, 200, 400,
dialog.setVisible(true);
你可能注意到为什么我写了两个监听事件，就是加以区分这些方法的区别：
第一种的监听处理部分，如果有多个（我就写过三十多个的事件监听，包含菜单栏按钮事件监听和工具栏按钮事件监听），那就需要一个个去判断，从理论上说是影响程序速度的。
第二种和第三种比较常用，如果程序的监听事件比较少，可以用第二种，匿名类很合适。
第三种符合面向对象编程（可以设置内部类只提供自身类使用，而且方便使用自身类的资源），尤其是适合多个监听事件的处理，当然也适合第二种方法情况。
第四种是外部类，如果多个监听事件相同，就可以选用此种方法。
个人愚见：建议初学者掌握这四种方法，侧重于第二、三种。怎么学不重要，重要的是达到目的，使自己的GUI编程运用自如。多编程，多思考，提升编程思想；多看别人的代码，取其精华，有很大帮助！
由于本人水平有限，如有不足，欢迎大家指出；也希望与大家多交流。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。