设计模式读书笔记之观察者模式(Observer)

观察者模式：让多个观察者可以监听某一个主题，当主题发生变化时，即使通知观察者，使他们自动能够更新自己。

类图就免了.

观察者模式比较简单, 通常的特征是:主题(被观察者)维护一个观察者序列, 当主题发生变化的时候,依次通知观察者,使之也改变自身.

基础示例：

[java] view plain copy

1. //抽象主题  
2. package designpattern.observer;  
3. public interface Subject {  
4.     public void attach(Observer o);  
5.     public void detach(Observer o);  
6.     public void notifyObservers();  
7. }  
8. //抽象观察者  
9. package designpattern.observer;  
10. public interface Observer {  
11.     public void update();  
12. }  
13. //具体主题  
14. package designpattern.observer;  
15. import <a href="http://lib.csdn.net/base/17" class='replace_word' title="Java EE知识库" target='_blank' style='color:#df3434; font-weight:bold;'>Java</a>.util.*;  
16.   
17. public class ConcreteSubject implements Subject{  
18.     public List<Observer> observers = new ArrayList();  
19.     public void attach(Observer o) {  
20.         observers.add(o);  
21.     }  
22.     public void detach(Observer o) {  
23.         observers.remove(o);  
24.     }  
25.     public void notifyObservers() {  
26.         for(Observer o : observers){  
27.             o.update();  
28.         }  
29.     }  
30.       
31. }  
32. //具体观察者  
33. package designpattern.observer;  
34.   
35. public class ConcreteObserver1 implements Observer{  
36.     public void update() {  
37.         System.out.println("I am observer 1, Subject's status changed.");  
38.     }  
39. }  
40. //具体观察者  
41. package designpattern.observer;  
42.   
43. public class ConcreteObserver2 implements Observer{  
44.     public void update() {  
45.         System.out.println("I am observer 2, Subject's status changed.");  
46.     }  
47. }  
48. //test case  
49. package designpattern.observer;  
50. public class Test {  
51.     public static void main(String[] args){  
52.         Subject s = new ConcreteSubject();  
53.         s.attach(new ConcreteObserver1());  
54.         s.attach(new ConcreteObserver2());  
55.         s.notifyObservers();  
56.     }  
57. }  

适应情景：当一个对象发生改变而同时需要改变其他对象时。

观察者模式的作用在于解耦， 就是让耦合的双方都依赖于抽象而不是具体。从而使得各部分的变化都不会影响到对方。

 

经典例子: awt中的事件模型.