观察者模式（浅谈监听器工作原理）

梦里梦外; 2022-05-26 07:54 194阅读 0赞

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

Java代码   ![收藏代码][icon_star.png]

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代码   ![收藏代码][icon_star.png]

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

Java代码   ![收藏代码][icon_star.png]

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代码   ![收藏代码][icon_star.png]

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代码   ![收藏代码][icon_star.png]

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代码   ![收藏代码][icon_star.png]

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代码   ![收藏代码][icon_star.png]

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代码   ![收藏代码][icon_star.png]

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

四    浅析监听器的工作原理

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

转载于:https://blog.csdn.net/duchao123duchao/article/details/50970747

[icon_star.png]: /images/20220526/b88ae539caef47b7a50f05eb6218fe1e.png