1. 程式人生 > >java設計模式--事件監聽器模式和觀察者模式

java設計模式--事件監聽器模式和觀察者模式

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

觀察者模式:觀察者(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. }    
查閱了一些相關的東東 
原來這兩種api可以說都是基於:訂閱-釋出模式的事件/訊息通知模式,二者應該都算是“推”方式吧,就是被監控者將訊息通知給所有監控者。 
1、訂閱:Observable.addObserver;
事件源.addDemoListener(這個方法是自己定義的)。 

2、釋出:Observable需要兩步:setChanged()、notifyObservers(newValue);  事件源.notifyDemoEvent()(這個方法也是自己定義的)。

相關推薦

no