java事件处理机制(自定义事件)

转载 2015年07月09日 10:47:54

java中的事件机制的参与者有3种角色:

1.event object:事件状态对象,用于listener的相应的方法之中,作为参数,一般存在与listerner的方法之中

2.event source:具体的事件源,比如说,你点击一个button,那么button就是event source,要想使button对某些事件进行响应,你就需要注册特定的listener。

3.event listener:具体的对监听的事件类,当它监听到event object产生的时候,它就调用相应的方法,进行处理。

先看看jdk提供的event包:
public interface EventListener:所有事件侦听器接口必须扩展的标记接口。
public class EventObject extends Object implements Serializable
所有事件状态对象都将从其派生的根类。 所有 Event 在构造时都引用了对象 “source”,在逻辑上认为该对象是最初发生有关 Event 的对象。

 在Java2处理事件时,没有采用dispatchEvent()-postEvent()-handleEvent()方式,采用了监听器类,每个事件类都有相关联的监听器接口。事件从事件源到监听者的传递是通过对目标监听者对象的Java方法调用进行的。

  对每个明确的事件的发生,都相应地定义一个明确的Java方法。这些方法都集中定义在事件监听者(EventListener)接口中,这个接口要继承 java.util.EventListener。 实现了事件监听者接口中一些或全部方法的类就是事件监听者。

  伴随着事件的发生,相应的状态通常都封装在事件状态对象中,该对象必须继承自java.util.EventObject。事件状态对象作为单参传递给应响应该事件的监听者方法中。发出某种特定事件的事件源的标识是:遵从规定的设计格式为事件监听者定义注册方法,并接受对指定事件监听者接口实例的引用。

首先问个问题:您熟悉java.util.EventObject 和java.util.EventListener两个类以及他们已有的子类吗?

如果你已经能够熟练使用jdk为我们提供的事件监听器,并且很熟悉MouseEvent, KeyEvent, WindowEvent等等这些jdk为我们准备好的事件,那么想必你对java的事件机制已经有所理解。但是也许你还是觉得虽然用起来没什么问题,但是原理还是有些糊涂,那么下面我们再进一步自己实现这些事件和监听器,即自定义事件。

其实自定义事件在java中很有用处,我们有的时候想让自己的程序产生一个事件,但有不希望(或者不可能)用鼠标,键盘之类的输入设备进行操作,比如你写一个应用程序,在这个程序中一旦收到邮件就对邮件进行相关处理,对于“收到邮件”这个事件,jdk中就没有定义。对于这样的事件,以及对于这样的事件的监听器,我们只能自己动手完成了。

那么下面就以实例开始我们这个“创新”的过程:首先,类EventObject作为父类用来生成我们自己的事件类,接口EventListener用来实现我们自己的监听器;剩下的事情就是如何注册这些事件以及测试他们了。

1)通过DoorEvent.java文件创建DoorEvent类,这个类继承EventObject。

/**
* 定义事件对象,必须继承EventObject
*/
package test;
import java.util.EventObject;
public class DoorEvent extends EventObject {
    private String doorState = "";//表示门的状态,有“开”和“关”两种

    public DoorEvent(Object source, String doorState) {
        super(source);
        this.doorState = doorState;
    }

    public void setDoorState(String doorState) {
        this.doorState = doorState;
    }

    public String getDoorState() {
        return this.doorState;
    }
}

(2)定义新的事件监听接口,该接口继承自EventListener;该接口包含对doorEvent事件的处理程序:

/**
* 定义监听接口,负责监听DoorEvent事件
*/
package test;
import java.util.EventListener;
public interface DoorListener extends EventListener {
    public void doorEvent(DoorEvent event);
}

通过上面的接口我们再定义事件监听类,这些类具体实现了监听功能和事件处理功能。

/**
* 该类为 门1监听接口的实现,做具体的开门,关门动作
*/
package test;
public class DoorListener1 implements DoorListener {
    public void doorEvent(DoorEvent event) {
        if(event.getDoorState()!=null&&event.getDoorState().equals("open"))
        {
             System.out.println("门1打开");
        }
        else
        {
              System.out.println("门1关闭");
        }
    }
}



/**
* 该类为 门2监听接口的实现,做具体的开门,关门,以及开灯,关灯动作
*/
package test;
public class DoorListener2 implements DoorListener {
    public void doorEvent(DoorEvent event) {
        if(event.getDoorState()!=null&&event.getDoorState().equals("open"))
        {
             System.out.println("门2打开,同时打开走廊的灯");
        }
        else
        {
              System.out.println("门2关闭,同时关闭走廊的灯");
        }
    }
}


---------------------------------------------------------------------------------------------------------------------------


(3)通过DoorManager.java创造一个事件源类,它用一个Collection listeners对象来存储所有的事件监听器对象,存储方式是通过addDoorListener(..)这样的方法。notifyListeners(..)是触发事件的方法,用来通知系统:事件发生了,你调用相应的处理函数吧。

/**
* 事件源对象,在这里你可以把它想象成一个控制开门关门的遥控器,
* (如果是在swing中,就类似一个button)
*/
package test;
import java.util.*;
public class DoorManager {
    private Collection listeners;
    /**
     * 添加事件
     * @param listener DoorListener
     */
    public void addDoorListener(DoorListener listener) {
        if (listeners == null) {
            listeners = new HashSet();
        }
        listeners.add(listener);
    }

    /**
     * 移除事件
     * @param listener DoorListener
     */
    public void removeDoorListener(DoorListener listener) {
        if (listeners == null)
            return;
        listeners.remove(listener);
    }

    /**
     * 触发开门事件
     */
    protected void fireWorkspaceOpened() {
        if (listeners == null)
            return;
        DoorEvent event = new DoorEvent(this, "open");
        notifyListeners(event);
    }

    /**
     * 触发关门事件
     */
    protected void fireWorkspaceClosed() {
        if (listeners == null)
            return;
        DoorEvent event = new DoorEvent(this, "close");
        notifyListeners(event);
    }

    /**
     * 通知所有的DoorListener
     */
    private void notifyListeners(DoorEvent event) {
        Iterator iter = listeners.iterator();
        while (iter.hasNext()) {
            DoorListener listener = (DoorListener) iter.next();
            listener.doorEvent(event);
        }
    }

}

--------------------------------------------------------------------------------------------------------------------------

(4)好了,最后写一个测试程序测试一下我们自定义的事件吧,这段程序应该不难理解吧:)

/**
* 主程序,就想象成要开门的哪个人
*/
package test;
public class DoorMain {
    public static void main(String []args)
    {
        DoorManager manager = new DoorManager();
        manager.addDoorListener(new DoorListener1());//给门1增加监听器
        manager.addDoorListener(new DoorListener2());//给门2增加监听器
        //开门
        manager.fireWorkspaceOpened();
        System.out.println("我已经进来了");
        //关门
        manager.fireWorkspaceClosed();
    }
}
----------------------------------------------------------------------------------------------------------------------------
运行DoorMain

门1打开 
门2打开,同时打开走廊的灯
我已经进来了
门1关闭
门2关闭,同时关闭走廊的灯



下面我们看一个jdk内部是如何处理事件机制的,你可以和上面的自定义事件做一个比较,你会高兴的发现机制是一样的。

/**
* java swing的监听器,实现ActionListener接口,注意参数:(事件状态类:ActionEvent)
* 
*/
package test;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

class SimpleListener implements ActionListener {
    /*
     * 利用该类来监听事件源产生的事件,利用响应机制
     */
    public void actionPerformed(ActionEvent e) {
        String buttonName = e.getActionCommand();
        if (buttonName.equals("按钮1"))
            System.out.println("按钮1 被点击");

    }
}


public class ActionTest {
    private static JFrame frame; // 定义为静态变量以便main使用
    private static JPanel myPanel; // 该面板用来放置按钮组件
    private JButton button1; // 这里定义按钮组件


    public ActionTest() { // 构造器, 建立图形界面
        // 新建面板
        myPanel = new JPanel();
        // 新建按钮
        button1 = new JButton("按钮1"); // 新建按钮1
        // 建立一个actionlistener让按钮1注册,以便响应事件
        SimpleListener ourListener = new SimpleListener();
        button1.addActionListener(ourListener);
        myPanel.add(button1); // 添加按钮到面板

    }


    public static void main(String s[]) {
        ActionTest gui = new ActionTest(); // 新建Simple1组件

        frame = new JFrame("Simple1"); // 新建JFrame
        // 处理关闭事件的通常方法
        frame.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });

        frame.getContentPane().add(myPanel);
        frame.pack();
        frame.setVisible(true);
    }
}

在这里,我们再看一下java中的事件机制的参与者的3种角色:

我们定义了一个SimpleListener 实现ActionListener接口,

1.event object:事件状态对象,用于listener的相应的方法之中。用了jdk提供的ActionEvent,不需要我们自己定义。

2.event source:具体的事件源,就是哪个button,,注册特定的SimpleListener。

3.event listener:具体的对监听的事件类,当它监听到event

object产生的时候,它就调用相应的方法,进行处理。这里是我们自己定义的SimpleListener。

是不是和上面自定义的事件在机制上完全一致呢?Yes

这里你也许会问,为什么event object不需要我们自己定义呢?你可以想一下,这是一个表示“事件状态变化”的类,你能扑获“鼠标变化”

吗?这好象和平台有关的低层编码了,所有所不可能扑获,也没有必要去扑获,这些jdk已经给我们实现了。简单的看一下ActionEvent这个类

,它继承了java.awt.AWTEvent, 在这个类的构造方法源码如下:

static {
/* ensure that the necessary native libraries are loaded */
Toolkit.loadLibraries();
if (!GraphicsEnvironment.isHeadless()) {
initIDs();
}
}

我们在看jdk官方的解释:

Toolkit是 Abstract Window Toolkit 的所有实际实现的抽象超类。Toolkit 的子类被用于将各种组件绑定到特定本机工具包实现。大多数应

用程序不应直接调用该类中的任何方法。Toolkit 定义的方法是“胶合剂”,将 java.awt 包中与平台无关的类与 java.awt.peer 中的对应物

连接起来。Toolkit 定义的一些方法能直接查询本机操作系统。

相关文章推荐

spring事件监听的功能

用一个简单的例子来实现spring事件监听的功能   这个例子主要功能是,记录那些用户是第一次登入系统,如果用户是第一次登入系统,则调用spring的事件监听,记录这些用户。   ...

一起学spring--spring事件机制--监听器

欢迎进入《一起学spring》系列博文第三篇, spring容器的事件监听机制,同样有事件、事件源和监听者。而spring中的事件需要继承ApplicationEvent,监听者需要继承Applic...

java事件处理机制 自定义事件

ava中的事件机制的参与者有3种角色:   1.event object:事件状态对象,用于listener的相应的方法之中,作为参数,一般存在与listerner的方法之中   2.event ...

java事件处理机制(自定义事件)

java中的事件机制的参与者有3种角色: 1.event object:事件状态对象,用于listener的相应的方法之中,作为参数,一般存在与listerner的方法之中 2.event sou...

java事件处理机制(自定义事件)

java中的事件机制的参与者有3种角色: 1.event object:事件状态对象,用于listener的相应的方法之中,作为参数,一般存在与listerner的方法之中 2.event...

java事件处理机制(自定义事件)/观察者模式

java事件处理机制(自定义事件) java中的事件机制的参与者有3种角色: 1.event object:事件状态对象,用于listener的相应的方法之中,作为参数,一般存在与lister...
  • szyyyp
  • szyyyp
  • 2014年05月19日 18:39
  • 538

自定义组件_事件处理机制

1、Android的事件触发和响应过程 A、事件完整的响应过程: 先传递事件:Activity -> ViewGroup -> View 再处理事件:View -> ViewGroup ->...

C#自定义事件处理程序

  • 2010年04月21日 10:28
  • 33KB
  • 下载

Java 自定义事件处理

ava中的事件机制的参与者有3种角色:   1.event object:事件状态对象,用于listener的相应的方法之中,作为参数,一般存在与listerner的方法之中   2.event so...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java事件处理机制(自定义事件)
举报原因:
原因补充:

(最多只允许输入30个字)