01观察者模式(一)

1.观察者定义了一种一对多依赖关系，让多个观察者同时监听某个主题对象。这个主题对象在状态上发生变化时，会通知所有的观者对象，让他们自动更新自己。----这里的主题对象就是被观察者

 

2.代码模拟

 

   抽象主题角色AbstractWatched.java

   public interface AbstractWatched {

Java代码  

1.     public void addWatcher(AbstractWatcher watcher);  
2.       
3.     public void removeWatcher(AbstractWatcher watcher);  
4.       
5.     public void removeAll();  
6.       
7.     public void fire();  
8. }  

      具体主题角色ConcreteWatched.java

   public class ConcreteWatched implements AbstractWatched {

Java代码  

1. private List<AbstractWatcher> watchers = new ArrayList<AbstractWatcher>();  
2.   
3. @Override  
4. public void addWatcher(AbstractWatcher watcher) {  
5.     watchers.add(watcher);  
6. }  
7.   
8. @Override  
9. public void removeAll() {  
10.     watchers.clear();  
11. }  
12.   
13. @Override  
14. public void removeWatcher(AbstractWatcher watcher) {  
15.     watchers.remove(watcher);  
16. }  
17.   
18. @Override  
19. public void fire() {  
20.       
21.     for(AbstractWatcher watcher : watchers){  
22.         watcher.update();  
23.     }  
24. }  

 

   抽象观察者角色

   public interface AbstractWatcher {

Java代码  

1. public void update();  
2.    

   

 

   具体观者角色

 

Java代码  

1. public class ConcreteWatcher implements AbstractWatcher {  
2.   
3.     @Override  
4.     public void update() {  
5.         System.out.println("update.....");  
6.     }  
7.   
8. }  

 

  测试代码：

 

Java代码  

1. public static void main(String[] args) {  
2.     //被观察者  
3.     AbstractWatched watched = new ConcreteWatched();  
4.       
5.     AbstractWatcher watcher1 = new ConcreteWatcher();  
6.     AbstractWatcher watcher2 = new ConcreteWatcher();  
7.     AbstractWatcher watcher3 = new ConcreteWatcher();  
8.       
9.     watched.addWatcher(watcher1);  
10.     watched.addWatcher(watcher2);  
11.     watched.addWatcher(watcher3);  
12.       
13.     watched.fire();  
14. }