since1499

导航

观察者模式(浅谈监听器工作原理)

 从某种角度来说，我们总是处于两种生活状态：观察者与被观察者。当处于观察者状态时，被观察的对象会向我们发出某种信息，使我们产生某种心理活动或行为状态的改变。当我们处于被观察者状态时，我们的行为活动又可以以信息的方式影响观察者。(大多数情况下是两种状态并存。) 
        作为一种面向对象的编程语言，java中的设计模式跟我们的生活模式十分相似，观察者模式也不例外。 
一    观察者模式定义与组成 
        观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，让他们能够自动更新自己 。主要分为四部分：1.抽象主题角色 2.抽象观察者角色 3.具体主题角色 4.具体观察者角色 
二    自定义观察者模式 

Java代码  收藏代码
  1. /**抽象主题角色： 
  2.  * 把所有对观察者对象的引用保存在一个集合中， 
  3.  * 每个抽象主题角色都可以有任意数量的观察者。 
  4.  * 抽象主题提供一个接口，可以增加和删除观察者角色。 
  5.  * 一般用一个抽象类或接口来实现  
  6.  */  
  7. public interface BeWatched {  
  8.       
  9.     //增加一个观察者  
  10.     public void addWatcher(Watcher watcher);  
  11.       
  12.     //删除一个观察者  
  13.     public void removeWatcher(Watcher watcher);  
  14.       
  15.     //通知所有的观察者  
  16.     public void notifyWatchers(String str);  
  17.       
  18. }  

 

Java代码  收藏代码
  1. /** 
  2.  * 抽象观察者角色：为所有观察者定义一个接口，在接到主题角色的通知时更新自己 
  3.  * @author Administrator 
  4.  * 
  5.  */  
  6. public interface Watcher {  
  7.       
  8.     //更新自己  
  9.     public void update(String str);  
  10.       
  11. }  

 

Java代码  收藏代码
  1. /** 
  2.  * 具体主题角色： 
  3.  * 实现抽象主题角色 
  4.  * @author Administrator 
  5.  * 
  6.  */  
  7. public class ConcreteWatched implements BeWatched{  
  8.     //创建一个队列来存储一个或多个观察者  
  9.     private ArrayList<Watcher> al= new ArrayList<Watcher>();  
  10.     @Override  
  11.     public void addWatcher(Watcher watcher) {  
  12.         al.add(watcher);//添加观察者到指定队列中  
  13.     }  
  14.     @Override  
  15.     public void removeWatcher(Watcher watcher) {  
  16.         al.remove(watcher);//从队列中删除观察者  
  17.     }  
  18.     @Override  
  19.     public void notifyWatchers(String str) {  
  20.         //遍历队列  
  21.         for(int i=0;i<al.size();i++){  
  22.             Watcher watcher = al.get(i);//获取队列中的观察者对象  
  23.             watcher.update(str);//调用它的update()方法  
  24.         }  
  25.     }  
  26. }  

 

Java代码  收藏代码
  1. /** 
  2.  * 具体的观察者角色： 
  3.  * 实现抽象观察者角色 
  4.  * @author Administrator 
  5.  * 
  6.  */  
  7. public class ConcreteWatcher implements Watcher{  
  8.     @Override  
  9.     public void update(String str) {  
  10.         System.out.println("已经收到通知："+str);  
  11.     }  
  12.   
  13. }  

 

Java代码  收藏代码
  1. /** 
  2.  * 测试类 
  3.  * @author Administrator 
  4.  * 
  5.  */  
  6. public class ClientTest {  
  7.     public static void main(String[] args){  
  8.         //创建被观察者对象  
  9.         ConcreteWatched watched = new ConcreteWatched();  
  10.         //创建观察者  
  11.         ConcreteWatcher watcher1 = new ConcreteWatcher();  
  12.         ConcreteWatcher watcher2 = new ConcreteWatcher();  
  13.         ConcreteWatcher watcher3 = new ConcreteWatcher();  
  14.         //添加多个观察者  
  15.         watched.addWatcher(watcher1);  
  16.         watched.addWatcher(watcher2);  
  17.         watched.addWatcher(watcher3);  
  18.         //通知观察者  
  19.         watched.notifyWatchers("你好！");  
  20.         //分割  
  21.         System.out.println("--------------------------------");  
  22.         //删除一个观察者  
  23.         watched.removeWatcher(watcher1);  
  24.         //再次通知观察者  
  25.         watched.notifyWatchers("很好！");  
  26.           
  27.     }  
  28. }  


    程序执行结果： 

Java代码  收藏代码
  1. 已经收到通知：你好！  
  2. 已经收到通知：你好！  
  3. 已经收到通知：你好！  
  4. --------------------------------  
  5. 已经收到通知：很好！  
  6. 已经收到通知：很好！  


三    对于java中的观察者模式 
        java中的内置观察者模式有两个类：一个是observable被观察者类，一个是observer观察者接口。大体上与自定义模式相同，我们编写程序时只需继承obervable类，具体实现observer接口就可以了。 
        值得注意的是：调用notifyObservers()方法之前，必须先调用setChanged()方法。这是因为observable类中把changed变量初始化为false,notifyObservers()方法会先检查该变量是否为true,如果不为ture，就不会调用update()方法，这就要我们调用notifyObservers()之前，先用setChanged()方法将changed变量设置为true。 

Java代码  收藏代码
  1. import java.util.Observable;  
  2. import java.util.Observer;  
  3.   
  4. class Observe extends Observable {  
  5.     // 程序的入口  
  6.     public static void main(String args[]) {  
  7.         Observe watched = new Observe();// 创建被观察对象  
  8.         FirstObserver watch = new FirstObserver();// 创建观察者对象（可以创建多个）  
  9.         watched.addObserver(watch);  
  10.         watched.toWatchers("你好！");  
  11.     }  
  12.   
  13.     // 通知观察者的方法  
  14.     public void toWatchers(String str) {  
  15.             this.setChanged();// 被观察者发生变化，把changed设置为true  
  16.             this.notifyObservers(str);// 通知观察者  
  17.         }  
  18. }  
  19.   
  20. class FirstObserver implements Observer {  
  21.     // 重写更新方法  
  22.     public void update(Observable o, Object arg) {  
  23.         System.out.println("被观察者发生变化，观察者已收到通知："+arg);  
  24.     }  
  25. }  

 

Java代码  收藏代码
  1. 被观察者发生变化，观察者已收到通知：你好！  


四    浅析监听器的工作原理 
        刚开始接触监听器的时候，很是不理解为什么我点击按钮(触发事件)监听器会自动运行，而且每当我应用监听器处理事件的时候，就会困惑不已。学完观察者模式之后，渐渐的对这个问题有了一个清晰地认识——首先，创建监听器对象(具体观察者对象),然后将监听器添加到事件源(具体主题角色)上，最后事件源变化触发事件(具体主题角色状态改变，通知观察者)！其实就是观察者模式的实现。

posted on 2014-01-02 15:02  skylink  阅读(620)  评论(0)  编辑  收藏  举报