设计模式之观察者模式案例学习

转载请注明出处：http://blog.csdn.net/droyon/article/details/8615794

观察者模式：

定义：定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并更新。----HeadFirst设计模式

案例代码下载

案例：

小花猫和猫头鹰以捉老鼠为生。现在有一个广播老鼠信息的主题。可小花狗也参合进来了。

Observable.java

public interface Observable {
public void registerObserver(Observer o);
public void removeObserver(Observer o);
public void notifyObserver();
}

Observer.java

public interface Observer {
public void update(Observable o,Object obj);
}

Subject.java    主题，实现了Observable，发现老鼠，进行广播

import java.util.ArrayList;

public class Subject implements Observable{
private ArrayList<Observer> mValues = new ArrayList<Observer>();
private Content mBody = new Content();

public Subject(){
}

@Override
public void registerObserver(Observer o) {
mValues.add(o);
}

@Override
public void removeObserver(Observer o) {
mValues.remove(o);
}

@Override
public void notifyObserver() {
for(Observer o :mValues){
o.update(this, mBody);
}
}

public void findMouse(String name,int num){
Content content = new Content(name, num);
mBody = content;
notifyObserver();
}

class Content{
private String mName;
private int mNum;

public Content(){
this(null,0);
}

public Content(String name,int num){
mName = name;
mNum = num;
}
@Override
public String toString() {
return "在"+mName+"家，有"+mNum+"只老鼠";
}
}

}

CatObserver.java 观察者，实现了Observer。观察Subject主题，如果Subject进行通知，就是收到通知信息

public class CatObserver implements Observer{
private String mName;
public CatObserver(String name){
mName = name;
}

public void registerSubjectObserver(Observable observable){
System.out.println("我是"+mName+"，我注册成为了观察者,我要捉老鼠");
observable.registerObserver(this);
}

@Override
public void update(Observable o, Object obj) {
if(o instanceof Subject){
System.out.println(mName+"收到了通知:"+obj);
}else if(o instanceof DogObserver2){
System.out.println(mName+"接收到小狗共享的信息:"+obj);
}
}

}

DogObserver.java

public class DogObserver implements Observer{
private String mName;

public DogObserver(String name){
mName = name;
}

public void registerSubjectObserver(Observable observable){
System.out.println("我是"+mName+"，我注册了成为了观察者，我要狗拿耗子");
observable.registerObserver(this);
}

@Override
public void update(Observable o, Object obj) {
if(o instanceof Subject){
System.out.println(mName+"收到了通知："+obj);
}
}

}

Maotouying.java

public class Maotouying implements Observer{
private String mName;
public Maotouying(String name){
mName = name;
}

public void registerSubjectObserver(Observable observable){
System.out.println("我是"+mName+"，我注册成为了观察者");
observable.registerObserver(this);
}

@Override
public void update(Observable o, Object obj) {
if(o instanceof Subject){
System.out.println(mName+"收到了通知："+obj);
}
}
}

ObserverTest.java

public class ObserverTest {
public static void main(String args[]){
Subject subject = new Subject();

DogObserver dog = new DogObserver("小花狗");
CatObserver cat = new CatObserver("小花猫");
Maotouying owl = new Maotouying("猫头鹰");

//注册成为观察者，subject发现耗子，就会通知的
dog.registerSubjectObserver(subject);
cat.registerSubjectObserver(subject);
System.out.println("----------------------------------------");
System.out.println("发现老鼠，发出通知:");
subject.findMouse("小丽家", 3);
System.out.println("----------------------------------------");
System.out.println("【想让猫头鹰也接收到通知，很容易扩展实现】");
owl.registerSubjectObserver(subject);
System.out.println("----------------------------------------");
System.out.println("发现老鼠，发出通知：");
subject.findMouse("小张家", 9);
}
}

测试结果：

我是小花狗，我注册了成为了观察者，我要狗拿耗子

我是小花猫，我注册成为了观察者,我要捉老鼠

----------------------------------------

发现老鼠，发出通知:

小花狗收到了通知：在小丽家家，有3只老鼠

小花猫收到了通知:在小丽家家，有3只老鼠

----------------------------------------

想让猫头鹰也接收到通知，很容易扩展实现

我是猫头鹰，我注册成为了观察者

----------------------------------------

发现老鼠，发出通知：

小花狗收到了通知：在小张家家，有9只老鼠

小花猫收到了通知:在小张家家，有9只老鼠

猫头鹰收到了通知：在小张家家，有9只老鼠

扩展：猫头鹰意识到它喜欢的是田鼠，不是耗子，它决定不再接收通知。小花狗也意识到它在多管闲事，它决定将信息分享（观察者可以成为主题，主题也可以成为观察者）

DogObserver2.java

import java.util.ArrayList;

public class DogObserver2 implements Observable,Observer{
private ArrayList<Observer> mData = new ArrayList<Observer>();
private String mName;
private Object content;
private boolean checked = false;

public DogObserver2(String name) {
mName = name;
}

public void registerSubjectObserver(Observable observable){
System.out.println("我是"+mName+"，我注册了成为了观察者，我要狗拿耗子");
observable.registerObserver(this);
}

@Override
public void registerObserver(Observer o) {
mData.add(o);
}

@Override
public void removeObserver(Observer o) {
mData.remove(o);
}

@Override
public void notifyObserver() {
for(Observer observer:mData){
observer.update(this, content);
}
}

@Override
public void update(Observable o, Object obj) {
content = obj;
if(checked){
System.out.println(mName+"不在狗拿耗子，分享耗子信息给他人");
notifyObserver();
}else{
System.out.println(mName+"收到了通知："+obj);
}
}

public void setChecked(boolean check){
checked = check;
}
}

ObserverTest2.java

public class ObserverTest2 {
public static void main(String args[]){
Subject subject = new Subject();

CatObserver cat1 = new CatObserver("小花猫1号");

DogObserver2 dog = new DogObserver2("小花狗");
CatObserver cat2 = new CatObserver("小花猫2号");
CatObserver cat3 = new CatObserver("小花猫3号");

Maotouying owl = new Maotouying("猫头鹰");

cat1.registerSubjectObserver(subject);//花猫注册主题
owl.registerSubjectObserver(subject);//猫头鹰注册主题
dog.registerSubjectObserver(subject);//小狗注册主题
cat2.registerSubjectObserver(dog);//花猫2号，注册小狗主题，成为”小狗“的观察者
cat3.registerSubjectObserver(dog);

subject.findMouse("小赵", 8);

System.out.println("猫头鹰不想接收通知了");
subject.removeObserver(owl);
System.out.println("小狗决定不再多管闲事，分享耗子信息给他人");
dog.setChecked(true);

subject.findMouse("小王", 2);
}
}

测试结果：

我是小花猫1号，我注册成为了观察者,我要捉老鼠

我是猫头鹰，我注册成为了观察者

我是小花狗，我注册了成为了观察者，我要狗拿耗子

我是小花猫2号，我注册成为了观察者,我要捉老鼠

我是小花猫3号，我注册成为了观察者,我要捉老鼠

小花猫1号收到了通知:在小赵家，有8只老鼠

猫头鹰收到了通知：在小赵家，有8只老鼠

小花狗收到了通知：在小赵家，有8只老鼠

猫头鹰不想接收通知了

小狗决定不再多管闲事，分享耗子信息给他人

小花猫1号收到了通知:在小王家，有2只老鼠

小花狗不在狗拿耗子，分享耗子信息给他人

小花猫2号接收到小狗共享的信息:在小王家，有2只老鼠

小花猫3号接收到小狗共享的信息:在小王家，有2只老鼠

jdk中也实现了观察者模式，本案例也可以使用jdk来实现。

总结：

HearFirst设计模式：
观察者模式提供了一中松耦合的代码设计，当两个对象松耦合时，他们依然可以交互，但是不清楚彼此的细节。观察者模式提供了一种对象设计，让主题和观察者模式之间可以松耦合。

关于观察者的一切，主题只知道观察者模式实现了某个接口，主题也不必知道观察者的具体类是谁，做了什么。

任何时候我们都可以增加、删除观察者，并且主题不受影响。因为主题唯一依赖的是实现了Observer接口的对象。

当有新类型的观察者出现时，我们不必须为了兼容新类型而去修改主题，我们只需让新类型观察者实现Observer接口，然后注册成为观察者。主题只会发送通知给所有实现了观察者接口的对象。

我们可以很容易的使用这种框架，实现代码复用。

低耦合的设计，改变任何一方，不会影响另一方。

低耦合、高内聚-----设计原则

松耦合的设计之所以能够让我们建立有弹性的OO系统，应对变化，便于扩展和维护，就是应为它将对象之间的互相依赖降到了最低。