監聽器模式：事件源經過事件的封裝傳給監聽器，當事件源觸發事件後，監聽器接收到事件物件可以回撥事件的方法

觀察者模式：觀察者(Observer)相當於事件監聽者，被觀察者(Observable)相當於事件源和事件，執行邏輯時通知observer即可觸發oberver的update,同時可傳被觀察者和引數

監聽器模式demo

1、首要定義事件源物件（事件源相當於單擊按鈕事件當中的按鈕物件、屬於被監聽者）：

1. publicclass DemoSource {     
2. private Vector repository = new Vector();//監聽自己的監聽器佇列   
3. public
    DemoSource(){}     
4. publicvoid addDemoListener(DemoListener dl) {     
5.            repository.addElement(dl);     
6.     }     
7. publicvoid 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、其次定義事件（狀態）物件（該事件物件包裝了事件源物件、作為引數傳遞給監聽器、很薄的一層包裝類）：

1. publicclass DemoEvent extends java.util.EventObject {     
2. public DemoEvent(Object source) {     
3. super(source);//source—事件源物件—如在介面上發生的點選按鈕事件中的按鈕   
4. //所有 Event 在構造時都引用了物件 "source"，在邏輯上認為該物件是最初發生有關 Event 的物件   
5.     }     
6. publicvoid say() {     
7.            System.out.println("This is say method...");     
8.     }     
9. }    

3、最後定義我們的事件偵聽器介面如下

1. publicinterface DemoListener extends java.util.EventListener {     
2. //EventListener是所有事件偵聽器介面必須擴充套件的標記介面、因為它是無內容的標記介面、   
3. //所以事件處理方法由我們自己宣告如下：   
4. publicvoid handleEvent(DemoEvent dm);     
5. }  

監聽器實現類

1. publicclass DemoListener1 implements DemoListener {     
2. publicvoid handleEvent(DemoEvent de) {     
3.               System.out.println("Inside listener1...");     
4.               de.say();//回撥   
5.        }     
6. }   

4、測試程式碼

1. publicclass TestDemo {     
2.    DemoSource ds;     
3. public TestDemo(){     
4. try{     
5.          ds = new DemoSource();     
6. //將監聽器在事件源物件中登記：   
7.          DemoListener1 listener1 = new DemoListener1();     
8.          ds.addDemoListener(listener1);     
9.          ds.addDemoListener(new DemoListener() {     
10. publicvoid handleEvent(DemoEvent event) {     
11.             System.out.println("Method come from 匿名類...");     
12.           }     
13.         });     
14.        ds.notifyDemoEvent();//觸發事件、通知監聽器   
15.      }catch(Exception ex){  
16.        ex.printStackTrace();  
17.        }     
18.     }     
19. publicstaticvoid main(String args[]) {     
20. new TestDemo();     
21.     }     
22. }    

觀察者模式demo

觀察者

1. class Watcher implements java.util.Observer {     
2. publicvoid update(java.util.Observable obj, Object arg) {     
3.     System.out.println("Update() called, count is "
4.                                 + ((Integer) arg).intValue());     
5. }     
6. }    

被觀察者

1. class BeingWatched extends java.util.Observable {     
2. void counter(int period) {     
3. for(; period<=0; period-- ) {     
4.                 setChanged();     
5.                 notifyObservers(new Integer(period));     
6. try {     
7.                         Thread.sleep(100);     
8.                 } catch( InterruptedException e) {     
9.                   System.out.println("Sleep interrupeted" );     
10.                 }     
11.         }     
12. }     
13. };     

測試

1. publicclass ObserverDemo {     
2. publicstaticvoid main(String[] args) {     
3.         BeingWatched beingWatched = new BeingWatched();//受查者   
4.         Watcher watcher = new Watcher();//觀察者   
5.         beingWatched.addObserver(watcher);     
6.         beingWatched.counter(10);     
7.     }     
8. }