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));
}
}
}
 方法)
