观察者模式

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

package com;class Child{private boolean wakeup=false;/** * 封装：一个对象特性 尽量只用自己来修改   为什么 不能直接访问属性 。 * 属性做成private 通过方法控制 , 可以达到比较精细的控制。有的只有get 方法（如身份） * @return */public boolean isWakeup() {  return wakeup;}public void setWakeup(boolean wakeup) {this.wakeup = wakeup;}void wakeup(){wakeup=true;}}class Dad implements Runnable{ //让Dag 不停的监测。Child  c;//一个类监听另外一个类，持有它的引用完全可以。构造方法里传递给他。@Overridepublic void run() {while(c.isWakeup()){try {Thread.sleep(1000);//每隔一秒的看一次醒了没有。} catch (InterruptedException e) {e.printStackTrace();}}}public Dad(Child c){this.c=c;}} public class Test {public static void main(String []args){Child c=new Child();new Thread(new Dad(c)).start();}}

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

package com;class Child implements Runnable{ //模拟程序使Child本身就是一个线程。Private boolean wakeup=false;/** * 封装：一个对象特性 尽量只用自己来修改   为什么 不能直接访问属性 。 * 属性做成private 通过方法控制 , 可以达到比较精细的控制。                   有的只有get 方法（如身份） * @return */public boolean isWakeup() {  return wakeup;}public void setWakeup(boolean wakeup) {this.wakeup = wakeup;}void wakeup(){wakeup=true;}@Overridepublic void run() {try {Thread.sleep(5000);//睡5秒钟} catch (InterruptedException e) {e.printStackTrace();}this.wakeup(); //5秒钟后醒过来了。}}class Dad implements Runnable{ //让Dag 不停的监测。Child  c;//一个类监听另外一个类，持有它的引用完全可以。构造方法里传递给他。@Overridepublic void run() {while(c.isWakeup()){try {Thread.sleep(1000);//每隔一秒的看一次醒了没有。} catch (InterruptedException e) {e.printStackTrace();}}feed(c);}public Dad(Child c){this.c=c;}private void feed(Child c){System.out.println("feed c");}} public class Test {public static void main(String []args){Child c=new Child();new Thread(c).start();new Thread(new Dad(c)).start();//本来下午还想干点别的事。现在变成模式你不能干别的事了要一直盯着他。3小时不醒一直循环着。}}

上面代码问题：

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

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

package com;class Child implements Runnable{//模拟程序使Child本身就是一个线程。Dad d;public Child(Dad d){this.d=d;}boolean wakeup=false;/** * 封装：一个对象特性 尽量只用自己来修改   为什么 不能直接访问属性 。 * 属性做成private 通过方法控制 , 可以达到比较精细的控制。                   有的只有get 方法（如身份） * @return */public boolean isWakeup() {  return wakeup;}public void setWakeup(boolean wakeup) {this.wakeup = wakeup;}void wakeup(){wakeup=true;d.feed(this);//Child 拥有了Dad引用  醒后直接通知Dad了。}@Overridepublic void run() {try {Thread.sleep(5000);//每隔一秒的看一次醒了没有。} catch (InterruptedException e) {e.printStackTrace();}this.wakeup();}}class Dad { //让Dag 不停的监测。public Dad(){}public void feed(Child c){System.out.println("feed c");}} public class Test {public static void main(String []args){Dad d=new Dad();new Thread(new Child(d)).start();}}

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

private long time;private String location;

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

class WakeupEvent{ //不能写在Child 里面。private long time;private String location;private Object source;WakeupEvent(long time,String location,Object source){this.time=time;this.location=location;this.source=source;}public long getTime() {return time;}public void setTime(long time) {this.time = time;}public String getLocation() {return location;}public void setLocation(String location) {this.location = location;}public Object getSource() {return source;}public void setSource(Object source) {this.source = source;}}

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

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

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

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

//WakeupEvent w=new WakeupEvent(System.currentTimeMillis(),"bed",c);        //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 并且把醒了后状况通知他们，他们根据具体情况采取具体动作。
代码如下：

package com;import java.util.ArrayList;import java.util.List;class Child implements Runnable{//模拟程序使Child本身就是一个线程。WakeupEvent w;private List <WakeUpLisener> wul=new ArrayList<WakeUpLisener>();//监听器列表，用来存储各种监听类，如Dad GroudFather Ancle.public void addWakupListener (WakeUpLisener k){wul.add(k);}public Child(){}boolean wakeup=false;/** * 封装：一个对象特性 尽量只用自己来修改   为什么 不能直接访问属性 。 * 属性做成private 通过方法控制 , 可以达到比较精细的控制。                   有的只有get 方法（如身份） * @return */public boolean isWakeup() {  return wakeup;}public void setWakeup(boolean wakeup) {this.wakeup = wakeup;}void wakeup(){ //醒过来想让他爸爸干别的事。for(int i=0;i<wul.size();i++){WakeUpLisener wl=wul.get(i);wl.ActionWakeUP(new WakeupEvent(System.currentTimeMillis(),"bed",this));//wul[i].ActionWakeUp 不行，只有 wul.get(i)才有ActionWakeUp()方法。}}@Overridepublic void run() {try {Thread.sleep(1000);//每隔一秒的看一次醒了没有。} catch (InterruptedException e) {e.printStackTrace();}this.wakeup();}}class Dad implements WakeUpLisener{ //让Dag 不停的监测。public Dad(){}public void ActionWakeUP(WakeupEvent w){System.out.println("Dad ActionWakeUP"+"location:"+w.getLocation()+",time:"+w.getTime());//可以是时间 可以是location。}}class GroudDad implements WakeUpLisener{ //让Dag 不停的监测。public GroudDad(){}public void ActionWakeUP(WakeupEvent w){System.out.println("GroundDad ActionWakeUP-"+"location:"+w.getLocation()+",time:"+w.getTime());//可以是时间 可以是location。}}interface WakeUpLisener{public void ActionWakeUP(WakeupEvent w);}class WakeupEvent{ //不能写在Child 里面。private long time;private String location;private Object source;WakeupEvent(long time,String location,Object source){this.time=time;this.location=location;this.source=source;}public long getTime() {return time;}public void setTime(long time) {this.time = time;}public String getLocation() {return location;}public void setLocation(String location) {this.location = location;}public Object getSource() {return source;}public void setSource(Object source) {this.source = source;}}public class Test {public static void main(String []args){Dad d=new Dad();//WakeupEvent w=new WakeupEvent(System.currentTimeMillis(),"bed",c);//Child c=new Child(w);Child c=new Child();c.addWakupListener(d);new Thread(c).start();GroudDad gd=new GroudDad();//添加一个不需修改。c.addWakupListener(gd);}}//如果要爷爷来抱怎么办 Child 这个类改变很大。//叔叔呢？ Child 类不断扩展。

运行结果为：

Dad ActionWakeUPlocation:bed,time:1318647314593GroundDad ActionWakeUP-location:bed,time:1318647314593

总结：

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

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

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

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

还可以继续封装
如

class CryEvent extends Event{}abstract class Event{}