观察者模式

学习设计模式从一个具体事情说起：
比如一个孩子在睡觉，爸爸要照看它，怎么写这样一个程序。
首先想到的是写一个Dad 类，一个Child 类，让Dad 类监听Child。
看如下代码：

[java]  view plain copy

1. package com;  
2. class Child{  
3.     private boolean wakeup=false;  
4.   
5.     /** 
6.      * 封装：一个对象特性 尽量只用自己来修改   为什么 不能直接访问属性 。 
7.      * 属性做成private 通过方法控制 , 可以达到比较精细的控制。有的只有get 方法（如身份） 
8.      * @return 
9.      */  
10.     public boolean isWakeup() {    
11.         return wakeup;  
12.     }  
13.   
14.     public void setWakeup(boolean wakeup) {  
15.         this.wakeup = wakeup;  
16.     }  
17.       
18.     void wakeup(){  
19.         wakeup=true;  
20.     }  
21. }  
22. class Dad implements Runnable{ //让Dag 不停的监测。  
23.     Child  c;//一个类监听另外一个类，持有它的引用完全可以。构造方法里传递给他。  
24.     @Override  
25.     public void run() {  
26.         while(c.isWakeup()){  
27.             try {  
28.                 Thread.sleep(1000);//每隔一秒的看一次醒了没有。  
29.             } catch (InterruptedException e) {  
30.                 e.printStackTrace();  
31.             }  
32.         }  
33.           
34.     }  
35.     public Dad(Child c){  
36.         this.c=c;  
37.     }  
38.       
39. }   
40. public class Test {  
41.     public static void main(String []args){  
42.         Child c=new Child();  
43.         new Thread(new Dad(c)).start();  
44.     }  
45. }  

运行结果为：
Dad 线程不停运行，因为小孩没有醒过来。
如何设置小伙子5分钟后醒过来呢？ 模拟线程，让Child 也是一个类，5秒钟后醒过来。
代码如下：

[java]  view plain copy

1. package com;  
2. class Child implements Runnable{ //模拟程序使Child本身就是一个线程。  
3.     Private boolean wakeup=false;  
4.   
5.     /** 
6.      * 封装：一个对象特性 尽量只用自己来修改   为什么 不能直接访问属性 。 
7.      * 属性做成private 通过方法控制 , 可以达到比较精细的控制。 
8.                    有的只有get 方法（如身份） 
9.      * @return 
10.      */  
11.     public boolean isWakeup() {    
12.         return wakeup;  
13.     }  
14.   
15.     public void setWakeup(boolean wakeup) {  
16.         this.wakeup = wakeup;  
17.     }  
18.       
19.     void wakeup(){  
20.         wakeup=true;  
21.     }  
22.   
23.     @Override  
24.     public void run() {  
25.         try {  
26.             Thread.sleep(5000);//睡5秒钟  
27.         } catch (InterruptedException e) {  
28.             e.printStackTrace();  
29.         }  
30.         this.wakeup(); //5秒钟后醒过来了。  
31.     }  
32. }  
33. class Dad implements Runnable{ //让Dag 不停的监测。  
34.     Child  c;//一个类监听另外一个类，持有它的引用完全可以。构造方法里传递给他。  
35.     @Override  
36.     public void run() {  
37.         while(c.isWakeup()){  
38.             try {  
39.                 Thread.sleep(1000);//每隔一秒的看一次醒了没有。  
40.             } catch (InterruptedException e) {  
41.                 e.printStackTrace();  
42.             }  
43.         }  
44.         feed(c);  
45.     }  
46.     public Dad(Child c){  
47.         this.c=c;  
48.     }  
49.     private void feed(Child c){  
50.         System.out.println("feed c");  
51.     }  
52.       
53. }   
54. public class Test {  
55.     public static void main(String []args){  
56.         Child c=new Child();  
57.         new Thread(c).start();  
58.         new Thread(new Dad(c)).start();  
59. //本来下午还想干点别的事。现在变成模式你不能干别的事了要一直盯着他。3小时不醒一直循环着。  
60.     }  
61. }  

上面代码问题：

1.程序里不断while 主动监听很耗资源

2.一个线程wait 怎么醒过来-notify()，谁负责线程醒过来。负责notify 的线程同样的也要监听Child 。多次一举。
解决办法：
( 关键点 )让Child来监听( 确定的说是通知d.WakeUp(this) ) Dad。代码如下：

[java]  view plain copy

1. package com;  
2. class Child implements Runnable{//模拟程序使Child本身就是一个线程。  
3.     Dad d;  
4.     public Child(Dad d){  
5.         this.d=d;  
6.     }  
7.     boolean wakeup=false;  
8.     /** 
9.      * 封装：一个对象特性 尽量只用自己来修改   为什么 不能直接访问属性 。 
10.      * 属性做成private 通过方法控制 , 可以达到比较精细的控制。 
11.                    有的只有get 方法（如身份） 
12.      * @return 
13.      */  
14.     public boolean isWakeup() {    
15.         return wakeup;  
16.     }  
17.     public void setWakeup(boolean wakeup) {  
18.         this.wakeup = wakeup;  
19.     }  
20.     void wakeup(){  
21.         wakeup=true;  
22.         d.feed(this);//Child 拥有了Dad引用  醒后直接通知Dad了。  
23.     }  
24.     @Override  
25.     public void run() {  
26.         try {  
27.             Thread.sleep(5000);//每隔一秒的看一次醒了没有。  
28.         } catch (InterruptedException e) {  
29.             e.printStackTrace();  
30.         }  
31.         this.wakeup();  
32.     }  
33. }  
34. class Dad { //让Dag 不停的监测。  
35.     public Dad(){  
36.     }  
37.     public void feed(Child c){  
38.         System.out.println("feed c");  
39.     }     
40. }   
41. public class Test {  
42.     public static void main(String []args){  
43.         Dad d=new Dad();  
44.         new Thread(new Child(d)).start();  
45.     }  
46. }  

这样就不需Dad 一直监听着可以干别的事。Child 醒了告诉Dad。
但还有问题：
1.
醒了包含很多信息， 几点 醒的。针对不同醒的方式处理方式不同行，包含一些具体情况。
应该把具体情况告诉他爸爸。小孩有责任把具体情况通知责任人。
如醒了时间 Java中 time 用long表示。 地点location.

[java]  view plain copy

1. private long time;  
2. private String location;  

可以把 time location 当做Child 成员，feed(C), Dad.feed(this) 就知道具体醒的时间 地点了等情况了。
且 time location 不应该是Child 的属性 （合适的属性放在合适的类）
2.但醒了还有其他情况 可以把他放在一个WakeUpEvent 类里。

[java]  view plain copy

1. class WakeupEvent{ //不能写在Child 里面。  
2.     private long time;  
3.     private String location;  
4.     private Object source;  
5.     WakeupEvent(long time,String location,Object source){  
6.         this.time=time;  
7.         this.location=location;  
8.         this.source=source;  
9.     }  
10.     public long getTime() {  
11.         return time;  
12.     }  
13.     public void setTime(long time) {  
14.         this.time = time;  
15.     }  
16.     public String getLocation() {  
17.         return location;  
18.     }  
19.     public void setLocation(String location) {  
20.         this.location = location;  
21.     }  
22.     public Object getSource() {  
23.         return source;  
24.     }  
25.     public void setSource(Object source) {  
26.         this.source = source;  
27.     }  
28. }  

如果Dad 要监听，
给Child 一个Dad 引用。

[java]  view plain copy

1. class Dad { //让Dag 不停的监测。  
2.     public Dad(){  
3.     }  
4.       
5.     public void ActionWakeUP(WakeupEvent w){  
6.         System.out.println("ActionWakeUP");//可以是时间 可以是location。  
7.     }  
8. }  

在Child 类里， Dad d ; 做为Child 的成员。
Child{
         Dad d;

         void wakeup(){ //
                  WakeupEvent w=new WakeupEvent(System.currentTimeMillis(),"bed",this); //注意参数里以this为参数的函数。
         }
}
/注意参数里以this为参数的函数。像下面代码是写不出来的。只能写在 Child 函数里用this 作为参数

[java]  view plain copy

1. //WakeupEvent w=new WakeupEvent(System.currentTimeMillis(),"bed",c);  
2.        //Child c=new Child(w);  

好了现在Child 醒了可以通知Dad 了，那么此时 GroudFather 该干什么呢？ Ancle该干什么呢？
Child {
      Dad d;
      GroudFather  gf;
     Ancle     an;
}
这样每加一个就要 修改Child .扩展性不好。
由此我们想到interface 方法：
Dad GroudFather Ancle 都继承 WakeUpLisener接口（接口多继承和多态特性）。并且具体实现WakeUpListener 接口的方法 ActionWakeUp () 。
这样当Child 醒了后，通知Dad GroudFather Ancle 并且把醒了后状况通知他们，他们根据具体情况采取具体动作。
代码如下：

[java]  view plain copy

1. package com;  
2.   
3.   
4. import java.util.ArrayList;  
5. import java.util.List;  
6.   
7. class Child implements Runnable{//模拟程序使Child本身就是一个线程。  
8.       
9.     WakeupEvent w;  
10.     private List <WakeUpLisener> wul=new ArrayList<WakeUpLisener>();//监听器列表，用来存储各种监听类，如Dad GroudFather Ancle.  
11.     public void addWakupListener (WakeUpLisener k){  
12.         wul.add(k);  
13.     }  
14.     public Child(){  
15.     }  
16.     boolean wakeup=false;  
17.     /** 
18.      * 封装：一个对象特性 尽量只用自己来修改   为什么 不能直接访问属性 。 
19.      * 属性做成private 通过方法控制 , 可以达到比较精细的控制。 
20.                    有的只有get 方法（如身份） 
21.      * @return 
22.      */  
23.     public boolean isWakeup() {    
24.         return wakeup;  
25.     }  
26.     public void setWakeup(boolean wakeup) {  
27.         this.wakeup = wakeup;  
28.     }  
29.     void wakeup(){ //醒过来想让他爸爸干别的事。  
30.         for(int i=0;i<wul.size();i++){  
31.             WakeUpLisener wl=wul.get(i);  
32.             wl.ActionWakeUP(new WakeupEvent(System.currentTimeMillis(),"bed",this));  
33.             //wul[i].ActionWakeUp 不行，只有 wul.get(i)才有ActionWakeUp()方法。  
34.         }  
35.     }  
36.     @Override  
37.     public void run() {  
38.         try {  
39.             Thread.sleep(1000);//每隔一秒的看一次醒了没有。  
40.         } catch (InterruptedException e) {  
41.             e.printStackTrace();  
42.         }  
43.         this.wakeup();  
44.     }  
45. }  
46.   
47. class Dad implements WakeUpLisener{ //让Dag 不停的监测。  
48.     public Dad(){  
49.     }  
50.     public void ActionWakeUP(WakeupEvent w){  
51.         System.out.println("Dad ActionWakeUP"+"location:"+w.getLocation()+",time:"+w.getTime());//可以是时间 可以是location。  
52.     }  
53. }  
54.   
55. class GroudDad implements WakeUpLisener{ //让Dag 不停的监测。  
56.     public GroudDad(){  
57.     }  
58.     public void ActionWakeUP(WakeupEvent w){  
59.         System.out.println("GroundDad ActionWakeUP-"+"location:"+w.getLocation()+",time:"+w.getTime());//可以是时间 可以是location。  
60.     }  
61. }  
62. interface WakeUpLisener{  
63.     public void ActionWakeUP(WakeupEvent w);  
64. }  
65. class WakeupEvent{ //不能写在Child 里面。  
66.     private long time;  
67.     private String location;  
68.     private Object source;  
69.     WakeupEvent(long time,String location,Object source){  
70.         this.time=time;  
71.         this.location=location;  
72.         this.source=source;  
73.     }  
74.     public long getTime() {  
75.         return time;  
76.     }  
77.     public void setTime(long time) {  
78.         this.time = time;  
79.     }  
80.     public String getLocation() {  
81.         return location;  
82.     }  
83.     public void setLocation(String location) {  
84.         this.location = location;  
85.     }  
86.     public Object getSource() {  
87.         return source;  
88.     }  
89.     public void setSource(Object source) {  
90.         this.source = source;  
91.     }  
92. }  
93. public class Test {  
94.     public static void main(String []args){  
95.         Dad d=new Dad();  
96.         //WakeupEvent w=new WakeupEvent(System.currentTimeMillis(),"bed",c);  
97.         //Child c=new Child(w);  
98.         Child c=new Child();  
99.         c.addWakupListener(d);  
100.         new Thread(c).start();  
101.         GroudDad gd=new GroudDad();//添加一个不需修改。  
102.         c.addWakupListener(gd);  
103.     }  
104. }  
105.   
106. //如果要爷爷来抱怎么办 Child 这个类改变很大。//叔叔呢？ Child 类不断扩展。  

运行结果为：

[java]  view plain copy

1. Dad ActionWakeUPlocation:bed,time:1318647314593  
2. GroundDad ActionWakeUP-location:bed,time:1318647314593  

总结：

1.用设计模式 类增加了但维护成本降低

2.Struct MVC 也是用了Observed 设计模式。

3.添加而不是修改。加一个新Observed只需建一个类   实现特点接口实现特点方法   在main方调用。如果不想建类可以在配置文件里Properties 或者把.properties 放在classpath 路径 通过JDK 中 Properties 来读取

4. 如果有代码复制来复制去  就要考虑代码封装。

还可以继续封装
如

[java]  view plain copy

1. class CryEvent extends Event{  
2.       
3. }  
4. abstract class Event{  
5.       
6. }