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

1.event object：就是事件产生时具体的“事件”，用于listener的相应的方法之中，作为参数，一般存在与listerner的方法之中

2.event source：具体的接受事件的实体，比如说，你点击一个button，那么button就是event source，这样你必须使button对某些事件进行相应，你就需要注册特定的listener，比如说MouseEvent之中的MouseClicked方法，这是他就必须有了add方法

3.event listener：具体的对监听的事件类，当有其对应的event object产生的时候，它就调用相应的方法，进行处理。在windows程序设计里边这种相应使用callback机制来实现的

先看看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中就没有定义。对于这样的事件，以及对于这样的事件的监听器，我们只能自己动手完成了。

其实呢，java事件处理机制就是观察者模式，我这里详细的整理一下，在并发编程中，动不动就给某一个主题注册一个监听，然后当主题状态发生变化的时候，监听就会被触发。好了，废话不多说了，我贴出几篇代码好了。

第一步：

/**

*

*/

package test;

/**

* @author LinkinPark

* @date 2015年8月31日 下午3:07:34

* @Description:

* 前面我已经整理了观察者模式，这里对照这个设计模式来整理下java事件

* 这里先写个最简单的模拟

*/

public class Util

{

public static void main(String[] args)

{

// 首先初始化一个被观察者，然后在初始化一个观察者

// 然后将观察者绑定到被观察者上面，然后使用被观察者看看观察者里面的事件有没有被触发

Observable observable = new Observable();

Observer observer = new Observer();

observable.setObserver(observer);

observable.test();//事件被成功的触发了

}

}

//这个模拟被观察者

class Observable

{

//绑定到被观察者上面的观察者

private Observer observer;

//被观察者对外面提供的操作

public void test()

{

observer.test();

}

public Observer getObserver()

{

return observer;

}

public void setObserver(Observer observer)

{

this.observer = observer;

}

}

// 这个模拟观察者

class Observer

{

// 这个模拟事件

public void test()

{

System.out.println("这里就是事件。。。");

}

}

第二步：

/**

*

*/

package test;

import java.util.ArrayList;

import java.util.List;

/**

* @author LinkinPark

* @date 2015年8月31日 下午3:07:34

* @Description:

* 现在在原来的基础上稍微复杂一点，现在不在被观察者身上只绑一个观察者了。

* 现在绑定多个观察者。

*/

public class Util

{

public static void main(String[] args)

{

// 首先初始化一个被观察者，然后在初始化2个观察者

// 然后将观察者绑定到被观察者上面，然后使用被观察者看看观察者里面的事件有没有被触发

Observable observable = new Observable();

Observer observer1 = new Observer();

Observer observer2 = new Observer();

observable.registObserver(observer1);

observable.registObserver(observer2);

//调用外部事件，看看观察者里面的事件执行了没有

observable.notifyObserver("被观察者触发了操作了呢");

}

}

// 这个模拟被观察者

class Observable

{

// 绑定到被观察者上面的观察者

private List observers = new ArrayList();

// 添加一个观察者到被观察者身上

public void registObserver(Observer observer)

{

observers.add(observer);

}

// 从绑定的观察者集合中去掉当前这个

public void removeObserver(Observer observer)

{

observers.remove(observer);

}

// 定义外部执行

public void notifyObserver(String str)

{

for (Observer observer : observers)

{

observer.test(str);

}

}

}

// 这个模拟观察者

class Observer

{

// 这个模拟事件

public void test(String str)

{

System.out.println("这里就是事件-->" + str);

}

}

第三步：

/**

*

*/

package test;

import java.util.ArrayList;

import java.util.List;

/**

* @author LinkinPark

* @date 2015年8月31日 下午3:07:34

* @Description:

* 现在在原来的基础上稍微复杂一点，现在不在被观察者身上只绑一个观察者了。

* 现在绑定多个观察者。现在在稍微复杂一点，观察者和被观察者都面向接口编程，里面提供多个实现

*/

public class Util

{

public static void main(String[] args)

{

// 首先初始化一个被观察者，然后在初始化2个观察者

// 然后将观察者绑定到被观察者上面，然后使用被观察者看看观察者里面的事件有没有被触发

Iobservable observable = new Observable();

Iobserver observer = new Observer();

Iobserver observer1 = new Observer1();

observable.registObserver(observer);

observable.registObserver(observer1);

// 调用被观察者的外部事件，看看观察者里面的事件执行了没有

observable.notifyObserver("被观察者触发了操作了呢");

}

}

// 被观察者对外提供的接口，其实这里定义成抽象类，也就是模板好一点。

interface Iobservable

{

// 绑定到被观察者上面的观察者

public List observers = new ArrayList();

// 添加一个观察者到被观察者身上

void registObserver(Iobserver observer);

// 从绑定的观察者集合中去掉当前这个

void removeObserver(Iobserver observer);

// 定义外部执行

public void notifyObserver(String str);

}

// 观察者对外提供的接口。

interface Iobserver

{

// 这个模拟事件

public void test(String str);

}

// 这个模拟被观察者

class Observable implements Iobservable

{

public void registObserver(Iobserver observer)

{

observers.add(observer);

System.out.println("这里添加一个被观察者-->" + observer.getClass());

}

public void removeObserver(Iobserver observer)

{

observers.remove(observer);

System.out.println("这里溢出一个被观察者-->" + observer.getClass());

}

public void notifyObserver(String str)

{

for (Iobserver observer : observers)

{

observer.test(str);

}

}

}

// 这个模拟观察者0

class Observer implements Iobserver

{

public void test(String str)

{

System.out.println("这里就是Observer事件-->" + str);

}

}

// 这个模拟观察者1

class Observer1 implements Iobserver

{

public void test(String str)

{

System.out.println("这里就是Observer1事件-->" + str);

}

}

第四步：

/**

*

*/

package test;

import java.util.ArrayList;

import java.util.List;

/**

* @author LinkinPark

* @date 2015年8月31日 下午3:07:34

* @Description:

* 现在在原来的基础上稍微复杂一点，现在不在被观察者身上只绑一个观察者了。

* 现在绑定多个观察者。现在在稍微复杂一点，观察者和被观察者都面向接口编程，里面提供多个实现。

* 最后现在提供一个最完美的观察者模式，其实和我前面那篇博客写的差不多

*/

public class Util

{

public static void main(String[] args)

{

// 首先初始化一个被观察者，然后在初始化2个观察者

// 然后将观察者绑定到被观察者上面，然后使用被观察者看看观察者里面的事件有没有被触发

Iobservable observable = new Observable();

Iobserver observer = new Observer();

Iobserver observer1 = new Observer1();

observable.registObserver(observer);

observable.registObserver(observer1);

// 调用被观察者的外部事件，看看观察者里面的事件执行了没有

System.out.println("===========华丽丽的分割线=============");

observable.notifyObserver("LinkinPark...");

}

}

// 被观察者对外提供的接口，其实这里定义成抽象类，也就是模板好一点。

abstract class Iobservable

{

// 绑定到被观察者上面的观察者

public List observers = new ArrayList();

// 添加一个观察者到被观察者身上

abstract void registObserver(Iobserver observer);

// 从绑定的观察者集合中去掉当前这个

abstract void removeObserver(Iobserver observer);

// 通知给观察者，让其开始做相关处理

public void notifyObserver(String str)

{

for (Iobserver observer : observers)

{

observer.test(str);

}

}

}

// 观察者对外提供的接口。

interface Iobserver

{

// 这个模拟事件

public void test(String str);

}

// 这个模拟被观察者

class Observable extends Iobservable

{

private String name;

public String getName()

{

return name;

}

// 在给这个被观察者重新设值name的时候，也就说现在观察者状态发生改变了，那么就要通知给观察者，让他也来做相关的处理

public void setName(String name)

{

this.name = name;

notifyObserver(name);

}

public void registObserver(Iobserver observer)

{

observers.add(observer);

System.out.println("这里添加一个被观察者-->" + observer.getClass());

}

public void removeObserver(Iobserver observer)

{

observers.remove(observer);

System.out.println("这里移除一个被观察者-->" + observer.getClass());

}

}

// 这个模拟观察者0

class Observer implements Iobserver

{

public Observer()

{

System.out.println("Observer:观察者原来的name-->" + getName());

}

private String name = "Observer";

public String getName()

{

return name;

}

public void setName(String name)

{

this.name = name;

}

public void test(String str)

{

System.out.println("Observer:原来的name-->" + getName());

setName(str);

System.out.println("被观察者状态改变后本地的同步name-->" + getName());

}

}

// 这个模拟观察者1

class Observer1 implements Iobserver

{

public Observer1()

{

System.out.println("Observer1:观察者原来的name-->" + getName());

}

private String name = "Observer1";

public String getName()

{

return name;

}

public void setName(String name)

{

this.name = name;

}

public void test(String str)

{

System.out.println("Observer1:原来的name-->" + getName());

setName(str);

System.out.println("被观察者状态改变后本地的同步name-->" + getName());

}

}

最后一步：java事件监听了呢。

package test;

import java.util.ArrayList;

import java.util.EventListener;

import java.util.EventObject;

import java.util.Iterator;

import java.util.List;

/**

* @author LinkinPark

* @date 2015年9月1日 下午1:46:52

* @Description: java事件监听机制

*/

public class Linkin

{

// 初始化主题-->被观察者

DemoSource source = new DemoSource();

// 初始化监听-->观察者

DemoListener Listener1 = new Listener1();

DemoListener Listener2 = new Listener2();

public Linkin()

{

source.addDemoListener(Listener1).addDemoListener(Listener2).addDemoListener(new DemoListener()

{

@Override

public void demoEvent(DemoEvent demoEvent)

{

System.out.println("匿名内部类收到主题推送-->" + demoEvent.getSource().getClass());

}

});

System.out.println("主题原来的状态-->" + name);

}

private String name = "nameOld";

/**

* @return the name

*/

public String getName()

{

return name;

}

/**

* @param name the name to set

*/

public void setName(String name)

{

this.name = name;

System.out.println("主题现在的状态-->" + name);

source.notifyDemoEvent();

}

public static void main(String[] args)

{

new Linkin().setName("nameNew");

}

}

// 就是事件产生时具体的“事件”，用于listener的相应的方法之中，作为参数，一般存在与listerner的方法之中

class DemoEvent extends EventObject

{

private static final long serialVersionUID = 1L;

Object obj;

public DemoEvent(Object source)

{

super(source);

obj = source;

}

public Object getSource()

{

return obj;

}

}

// 具体的对监听的事件类，当有其对应的event object产生的时候，它就调用相应的方法，进行处理。

interface DemoListener extends EventListener

{

void demoEvent(DemoEvent demoEvent);

}

// 这个相当于观察者

class Listener1 implements DemoListener

{

@Override

public void demoEvent(DemoEvent demoEvent)

{

System.out.println("Listener1监听收到了主题的推送消息" + demoEvent.getSource());

}

}

// 这个相当于观察者

class Listener2 implements DemoListener

{

@Override

public void demoEvent(DemoEvent demoEvent)

{

System.out.println("Listener2监听收到了主题的推送消息" + demoEvent.getSource());

}

}

// 具体的接受事件的实体，也就是观察者模式中的被观察者。比如说，你点击一个button，那么button就是event source，

// 这样你必须使button对某些事件进行相应，你就需要注册特定的listener，比如说MouseEvent之中的MouseClicked方法，这是他就必须有了add方法

class DemoSource

{

private List repository = new ArrayList();

DemoListener dl;

public DemoSource()

{

}

// 添加监听

public DemoSource addDemoListener(DemoListener dl)

{

repository.add(dl);

return this;

}

// 状态改变被触发

public void notifyDemoEvent()

{

Iterator it = repository.iterator();

while (it.hasNext())

{

dl = (DemoListener) it.next();

dl.demoEvent(new DemoEvent(this));

}

}

}