“事件”这个词已经被滥用了。正因为“事件”的被滥用，很多人在用到事件的时候不求甚解，依样画葫芦，导致学习工作了很多年，还是不清楚什么是事件处理器、什么是事件持有者。所以，如果你对于Event这个词还是心存恐惧，那么本文正是你需要的。让我们从易到难，从具体到抽象，一步一步来解释Java事件处理机制。
一：观察者模式
要了解事件和监听，我们首先来必须要了解观察者模式。
什么是观察者模式，我们先来看一个熟悉的场景：
1：教师布置作业，通知学生；
2：学生观察到老师布置了作业，开始做作业；
首先我明确下，我历来是十分反对以阿猫阿狗、老师学生这样的场景来阐述代码问题的，所以该主题的最后肯定会回到实际代码中来。言归正传，在这个场景中，学生就是观察者，教师就是被观察者，但是大家一定要注意：
教师作为被观察者，实际上是掌握着主动的，且看上文中我加粗的“通知”二字，因为这貌似看上去简简单单的通知，事实上却要做很多事情（写很多代码）。
好了，我们先来实现上面的场景：
代码：
观察者，学生
package com.zuikc.events;
import java.util.Observable;
public class Student implements java.util.Observer {
private String name;
public Student(String name){
this.name = name;
}
@Override
public void update(Observable o, Object arg) {
Teacher teacher = (Teacher) o;
System.out.printf("学生%s观察到（实际是被通知）%s布置了作业《%s》 \n", this.name, teacher.getName(), arg);
}
}
被观察者，教师
package com.zuikc.events;
import java.util.*;
public class Teacher extends java.util.Observable {
private String name;
private List<String> homeworks;
public String getName() {
return this.name;
}
public Teacher(String name) {
this.name = name;
homeworks = new ArrayList<String>();
}
public void setHomework(String homework) {
System.out.printf("%s布置了作业%s \n", this.name, homework);
homeworks.add(homework);
setChanged();
notifyObservers(homework);
}
}
客户端：
package com.zuikc.events;
public class Client {
public static void main(String[] args) {
Student student1= new Student("张三");
Student student2 = new Student("李四");
Teacher teacher1 = new Teacher("zuikc");
teacher1.addObserver(student1);
teacher1.addObserver(student2);
teacher1.setHomework("事件机制第一天作业");
}
}
很多初学者有个错觉，考虑“观察”这个动作是主动的，所以就认为在代码实现上，Reader是主动调用自己的update，但是很遗憾，当然不是，在代码实现上，update是“被观察者”Teacher主动调用的。有人说，我只在Teacher中看到了
setChanged();
notifyObservers(homework);
没有看到它调用update呀，那么请查看它的父类Observable，在notifyObservers方法中有，
for (int i = arrLocal.length-1; i>=0; i--)
((Observer)arrLocal[i]).update(this, arg);
看看结果吧：
注意，以上代码中，我直接使用了java.util包中的类Observable和接口Observer，我们当然也可以自己写这两个东东。
二：基础版观察者模式
初学者对于一上来就使用java.util中的api不习惯，可能觉得看不到摸不着，那我们就自己来写一个基础版的观察者模式，大家感受下，在写的过程中，一定要对照上节中的UML图和代码，然后心中默念：它们没有区别，它们没有区别！
上图：
上代码：
观察者，接口
package com.zuikc;
public interface Observer {
void update(Observable o);
}
具体观察者，我写了两个：
class ConcreteObserver1 implements Observer {
public void update(Observable o) {
System.out.println("观察者1观察到" + o.getClass().getSimpleName() + "发生变化");
System.out.println("观察者1做出响应");
}
}
class ConcreteObserver2 implements Observer {
public void update(Observable o) {
System.out.println("观察者2观察到" + o.getClass().getSimpleName() + "发生变化");
System.out.println("观察者2做出响应");
}
}
观察者
package com.zuikc;
import java.util.ArrayList;
import java.util.List;
public class Observable {
List<Observer> observers = new ArrayList<Observer>();
public void addObserver(Observer o) {
observers.add(o);
}
public void doSomething() {
System.out.println("我是被观察者，我发生变化了");
// 主动去通知所有的观察者
notifyObservers();
}
public void notifyObservers() {
for (Observer observer : observers) {
observer.update(this);
}
}
}
客户端：
package com.zuikc;
public class Client {
public static void main(String[] args) {
Observable observable = new Observable();
observable.addObserver(new ConcreteObserver1());
observable.addObserver(new ConcreteObserver2());
observable.doSomething();
}
}
大家可以自己运行下代码，看看发生了什么。
在上面代码中，我们自己了一个接口，一个被观察者类，虽然简单了一点，但是却达到了演示的效果。当然，我们也可以原封不动的把JDK中的源码拷贝出来作为我们这两个文件的代码。
如果对于上面的代码已经相当之熟悉，你还可以研究下update方法，在第一小节中我们是带了arg参数的，但是这个基础版本中没带。无所谓，你想带就带，不想带就不想带，代码即自由，只要你实现了功能。
三：观察者模式的用意
基础版的观察者模式毕竟太简单，在我们第一节中的代码中，我们可以总结出：
1：教师类和学生类无关，他只依赖观察者接口，如果有一天，他的作业不仅仅布置给学生，作为优秀讲师，还要发送给全校的老师作为参考，那么只要老师这个类也实现观察者接口，我们同样可以将老师添加到这个教师的观察者列表中；
2：观察者模式分离了观察者和被观察者自身的责任，让类各自维护自己的功能，提高了系统的可重用性；
3：观察看上去是一个主动的行为，但是其实观察者不是主动调用自己的业务代码的，相反，是被观察者调用的。所以，观察者模式还有另一个名字，叫发布-订阅模式，我认为，后者更贴切；
观察者模式还有另外一种形态，就是事件驱动模型，这两种方式在实现机制上是非常接近的，在理解了观察者模式的基础上，理解事件驱动，就非常简单了。