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

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

java事件机制包括三个部分：事件、事件监听器、事件源。

1、事件。一般继承自java.util.EventObject类，封装了事件源对象及跟事件相关的信息。

也就是这个事件有哪些属性和行为，比如说门，有打开和关闭两种行为

2、事件监听器。实现java.util.EventListener接口,注册在事件源上。 当事件源的属性或状态改变时,取得相应的监听器调用其内部的回调方法。

比如是门的话，做具体的开门，关门，以及开灯，关灯动作

3、事件源。事件发生的地方，由于事件源的某项属性或状态发生了改变(比如BUTTON被单击、TEXTBOX的值发生改变等等)导致某项事件发生。换句话说就是生成了相应的事件对象。

因为事件监听器要注册在事件源上,所以事件源类中应该要有盛装监听器的容器(List,Set等等)。

事件源对象，在这里你可以把它想象成一个控制开门关门的遥控器

（1）通过DoorEvent.java文件创建DoorEvent类，这个类继承EventObject。

/**
* 定义事件对象，必须继承EventObject
*/

public class DoorEvent extends EventObject {

    private static final long serialVersionUID = 6496098798146410884L;

    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事件
*/

public interface DoorListener extends EventListener {
     public void doorEvent(DoorEvent event);
}

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

/**
* 该类为 门1监听接口的实现，做具体的开门，关门动作
*/

public class DoorListener1 implements DoorListener {
    @Override
    public void doorEvent(DoorEvent event) {
        // TODO Auto-generated method stub
        if (event.getDoorState() != null && event.getDoorState().equals("open")) {
            System.out.println("门1打开");
        } else {
            System.out.println("门1关闭");
        }
    }

}

/**

* 该类为 门2监听接口的实现，做具体的开门，关门，以及开灯，关灯动作
*/

public class DoorListener2 implements DoorListener {

    @Override
    public void doorEvent(DoorEvent event) {
        // TODO Auto-generated method stub
        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)
*/

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）好了，最后写一个测试程序测试一下我们自定义的事件吧，这段程序应该不难理解吧：）

/**
* 主程序，就想象成要开门的哪个人
*/

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关闭，同时关闭走廊的灯