Java设计模式分析之观察者

　观察者模式的流程跟报纸订阅方式一致，即：观察者模式=出版者+订阅者，只是名称不一样，出版者改称为“主题”（Subject），订阅者改称为“观察者”（Observer）。
　　观察者定义：
　　观察者模式定义了对象之间的一对多依赖，当一个对象改变状态时，它的所有依赖者都会受到通知并自动更新。
　　主题接口（Subject）：对象使用此接口注册为观察者，或者把自己从观察者中删除。
　　具体主题（ConcreteSubject）：一个具体主题总是实现主题接口，除了注册*和撤销方法以外，具体主题还实现了notifyObserves（）方法，此方法用于在状态改变时更新所有当前观察者。
　　观察者（Observer）：为那些在目标发生改变时需获得通知的对象定义更新的接口
　　具体观察者（ConcreteObserver）：具体观察者实现了观察者Observer接口，并注册具体主题，以便接收更新。
　　观察者模式提供了一种对象设计，让主题和观察者之间松耦合，当两个对象之间松耦合，它们依然可以交互，但是不太清楚彼此的细节，主题只知道观察者实现了Observer接口，不需要知道观察者的具体类是谁，做了些什么其他的细节。
　　观察者实例：
　　通过ConcreteObserver注册两个观察者ConcreteObserverA和ConcreteObserverB，一旦被观察者有更新，两个观察者会立刻收到更新通知。具体代码如下：
　　声明Subject主题接口，Subject.java：
　　publicinterfaceSubject { voidregisterObserver（Observer observer）;voidremoveObserver（Observer observer）; voidnotifyObservers（）; }
　　声明ConcreteObserver具体主题，NetConcreteSubject.java：
　　publicclassNetConcreteSubjectimplementsSubject{privateList《Observer》 observers;privateObserverBean bean; publicNetConcreteSubject（） { observers = newArrayList《》（）; }@OverridepublicvoidregisterObserver（Observer observer） { observers.add（observer）; }@OverridepublicvoidremoveObserver（Observer observer） { intpos = observers.indexOf（observer）; if（pos 》 0） { observers.remove（pos）; } }@OverridepublicvoidnotifyObservers（） { if（bean == null） return; for（ inti = 0; i 《 observers.size（）; i++） { Observer observer = observers.get（i）; observer.update（bean）; } }publicvoidsetStatusChanged（ObserverBean bean） { this.bean = bean; notifyObservers（）; } }
　　声明观察者接口， Observer.java：
　　publicinterfaceObserver { voidupdate（Object obj）; }
　　声明具体观察者类，ConcreteObserverA.java：
　　publicclassConcreteObserverAimplementsObserver{@Overridepublicvoidupdate（Object obj） { if（obj instanceofObserverBean） { ObserverBean bean = （ObserverBean） obj; System.out.print（ “ConcreteObserverA 网络类型：”+ bean.netType + “，网络状态：”+ bean.netStatus + “\n”）; } } }
　　ConcreteObserverB.java：
　　publicclassConcreteObserverBimplementsObserver{@Overridepublicvoidupdate（Object obj） { if（obj instanceofObserverBean） { ObserverBean bean = （ObserverBean） obj; System.out.print（ “ConcreteObserverB 网络类型：”+ bean.netType + “，网络状态：”+ bean.netStatus + “\n”）; } } }
　　调用过程：
　　publicstaticvoidmain（String［］ args） { //初始化主题（被观察者）NetConcreteSubject subject =newNetConcreteSubject（）; //初始化观察者AConcreteObserverA observerA =newConcreteObserverA（）; //初始化观察者BConcreteObserverB observerB =newConcreteObserverB（）; //注册观察者Asubject.registerObserver（observerA）; //注册观察者Bsubject.registerObserver（observerB）; //通知所有观察者数据有更新ObserverBean bean = newObserverBean（ “wifi”， “有网”）; subject.setStatusChanged（bean）; }
　　运行结果：
　　ConcreteObserverA 网络类型：wifi，网络状态：有网 ConcreteObserverB 网络类型：wifi，网络状态：有网Java内置观察者：
　　Observable.java：
　　/** * Java学习交流QQ群：589809992 我们一起学Java！ */publicclassObservable{privatebooleanchanged = false; privateVector《Observer》 obs =newVector（）; publicObservable（） { } publicsynchronizedvoidaddObserver（Observer var1） {if（var1 == null） { thrownewNullPointerException（）; } else{ if（！ this.obs.contains（var1）） {this.obs.addElement（var1）; } } } publicsynchronizedvoiddeleteObserver（Observer var1） {this.obs.removeElement（var1）; } publicvoidnotifyObservers（） {this.notifyObservers（（Object） null）; } publicvoidnotifyObservers（Object var1） { Object［］ var2; synchronized（ this） { if（！ this.changed） { return; } var2 = this.obs.toArray（）;this.clearChanged（）; } for（ intvar3 = var2.length - 1; var3 》= 0; --var3） { （（Observer）var2［var3］）.update（ this， var1）; } } publicsynchronizedvoiddeleteObservers（） {this.obs.removeAllElements（）; } protectedsynchronizedvoidsetChanged（） { this.changed =true; } protectedsynchronizedvoidclearChanged（） { this.changed = false; }publicsynchronizedbooleanhasChanged（） { returnthis.changed; }publicsynchronizedintcountObservers（） { returnthis.obs.size（）; } }
　　Observer.java：
　　publicinterfaceObserver { voidupdate（Observable var1， Object var2）; }
　　上面的Observer和Observable类都位于java.util目录中，是JDK中已经写好的，那么我们可以直接拿来用了：
　　主题类NetSubject.java：
　　publicclassNetSubjectextendsObservable{publicvoidsetNetChanged（ObserverBean bean）{ setChanged（）; notifyObservers（bean）; } }
　　观察者SystemObserverA.java：
　　publicclassSystemObserverAimplementsObserver{@Overridepublicvoidupdate（Observable observable， Object o） { if（o instanceofObserverBean && observable instanceofNetSubject） { ObserverBean bean = （ObserverBean） o; System.out.print（ “ConcreteObserverA 网络类型：”+ bean.netType + “，网络状态：”+ bean.netStatus + “\n”）; } } }
　　观察者SystemObserverB.java：
　　/** * Java学习交流QQ群：589809992 我们一起学Java！ */publicclassSystemObserverBimplementsObserver{@Overridepublicvoidupdate（Observable observable， Object o） { if（o instanceofObserverBean && observable instanceofNetSubject） { ObserverBean bean = （ObserverBean） o; System.out.print（ “ConcreteObserverB 网络类型：”+ bean.netType + “，网络状态：”+ bean.netStatus + “\n”）; } } }
　　执行程序：
　　//初始化主题（被观察者）NetSubject subject = newNetSubject（）; //初始化观察者ASystemObserverA observerA = newSystemObserverA（）; //初始化观察者BSystemObserverB observerB = newSystemObserverB（）; //注册观察者Asubject.addObserver（observerA）; //注册观察者Bsubject.addObserver（observerB）; //通知观察者有更新ObserverBean bean = newObserverBean（ “4G流量”， “有网”）; subject.setNetChanged（bean）;
　　运行结果：
　　ConcreteObserverB 网络类型：4G流量，网络状态：有网 ConcreteObserverA 网络类型：4G流量，网络状态：有网