关于观察者模式的问题

原文地址： http://www.iteye.com/topic/182643

一、java.util.Observer —— 观察者接口 对应：
    java.util.Observable ——受查者根类

二、java.util.EventListener —— 事件监听/处理接口 对应：
    java.util.EventObject —— 事件（状态）对象根类

研究了一下发现这两种接口的目的、功能其实是一样的（仅在事件模型的结构上有些许差异），先看EventListener事件监听器模式：

1、首要定义事件源对象（事件源相当于单击按钮事件当中的按钮对象、属于被监听者）：

Java代码  

1. public class DemoSource {  
2.     private Vector repository = new Vector();//监听自己的监听器队列  
3.     public DemoSource(){}  
4.     public void addDemoListener(DemoListener dl) {  
5.            repository.addElement(dl);  
6.     }  
7.     public void notifyDemoEvent() {//通知所有的监听器  
8.            Enumeration enum = repository.elements();  
9.            while(enum.hasMoreElements()) {  
10.                DemoListener dl = (DemoListener)enum.nextElement();  
11.                  dl.handleEvent(new DemoEvent(this));  
12.            }  
13.     }  
14. }  

2、其次定义事件（状态）对象（该事件对象包装了事件源对象、作为参数传递给监听器、很薄的一层包装类）：

Java代码  

1. public class DemoEvent extends java.util.EventObject {  
2.     public DemoEvent(Object source) {  
3.       super(source);//source—事件源对象—如在界面上发生的点击按钮事件中的按钮  
4.        //所有 Event 在构造时都引用了对象 "source"，在逻辑上认为该对象是最初发生有关 Event 的对象  
5.     }  
6.     public void say() {  
7.            System.out.println("This is say method...");  
8.     }  
9. }  

3、最后定义我们的事件侦听器接口如下：

Java代码  

1. public interface DemoListener extends java.util.EventListener {  
2.     //EventListener是所有事件侦听器接口必须扩展的标记接口、因为它是无内容的标记接口、  
3.     //所以事件处理方法由我们自己声明如下：  
4.     public void handleEvent(DemoEvent dm);  
5. }  

4、测试代码：

Java代码  

1. //定义具体的事件监听器：  
2. public class DemoListener1 implements DemoListener {  
3.        public void handleEvent(DemoEvent de) {  
4.               System.out.println("Inside listener1...");  
5.               de.say();//回调  
6.        }  
7. }  
8.   
9. public class TestDemo {  
10.     DemoSource ds;  
11.   
12.     public TestDemo(){  
13.       try{  
14.                  ds = new DemoSource();  
15.   
16.                  //将监听器在事件源对象中登记：  
17.                  DemoListener1 l1 = new DemoListener1();  
18.                  ds.addDemoListener(l1);  
19.                  ds.addDemoListener(new DemoListener() {  
20.                             public void handleEvent(DemoEvent event) {  
21.                                       System.out.println("Method come from 匿名类...");  
22.                             }  
23.                  });  
24.   
25.   
26.                  ds.notifyDemoEvent();//触发事件、通知监听器  
27.   
28.            }catch(Exception ex) {ex.printStackTrace();}  
29.     }  
30.   
31.     public static void main(String args[]) {  
32.            new TestDemo();  
33.     }  
34. }  

再看Observer观察者模式：
Observer和EventListener的区别仅仅在于它提前声明了事件处理方法：
    update(Observable o, Object arg)
Observer模式当中不存在对应EventObject的角色，Observable被观察者就兼具了source事件源和EventObject事件对象两种角色，模型更简洁。
Observable被观察者根类就持有了观察者队列，也定义了类似notifyDemoEvent()的notifyObservers()方法...

除了结构有差异外实在看不出Observer观察者模式和EventListener事件监听/处理模式的不一样！请教二者还有什么差异吗？