观察者模式

讨论一下观察者模式
观察者模式定义了对象间的一种一对多依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。
它将观察者和被观察者的对象分离开。提高了应用程序的可维护性和重用性。
实现观察者模式有很多形式，一种是“注册—通知—撤销注册”的形式。
观察者Observer：所有潜在的观察者必须实现观察者接口，这个接口只有update方法，当主题改变时，它被调用。
具体观察者ConcreteObserver: 具体观察者可以是任何实现了Observer接口的类。观察者必须注册具体主题，一边接收更新。
可观察者Subject: 主题接口，即可观察者Observable，对象使用此接口注册为观察者，或者把自己从观察者中删除，每个主题可以有多个观察者。
具体可观察者ConcreteSubject: 一个具体主题实现了主题接口，除了注册和撤销之外，具体主题还实现了notifyObservers()方法，这个方法用来在主题状态改变时更新所有观察者。具体主题也可能有设置和获取状态的方法。

public interface Subject {
    public void attach(Observer observer);
    public void detach(Observer observer);
    public void notify(String msg);
}

public interface Observer {
    public void update(String msg);
}

import java.util.ArrayList;
import java.util.List;


public class SubscriptionSubject implements Subject {
    private List<Observer> observers=new ArrayList<Observer>();
    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notify(String msg) {
        for (Observer observer : observers) {
            observer.update(msg);
        }
    }

}

public class WeiXinUser implements Observer {
    private String name;

    public String getName() {
        return name;
    }

    public WeiXinUser(String name) {
        super();
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void update(String msg) {
        System.out.println(name+"-------------------receive----------------"+msg);
    }

}

public class Main {


    public static void main(String[] args) {
        Observer observer1=new WeiXinUser("1");
        Observer observer2=new WeiXinUser("2");
        Observer observer3=new WeiXinUser("3");
        Subject subject=new SubscriptionSubject();
        subject.attach(observer1);
        subject.attach(observer2);
        subject.attach(observer3);
        subject.notify("555555555555555555555");
    }

}

1——————-receive—————-555555555555555555555
2——————-receive—————-555555555555555555555
3——————-receive—————-555555555555555555555

这就是观察者模式，在jdk中提供了自带的观察者模式。

观察者模式定义：
观察者（Observer）模式又名发布-订阅（Publish/Subscribe）模式。GOF给观察者模式如下定义：定义对象Observer间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

Observable和Observer的说明：
继承于Observable的子类表示被观察的对象，实现了接口Observer的类表示观察者.在下面的例子中继承于Observable的子类 NewsDispatcher(新闻派发器)表示被观察的对象，在有新的新闻的时候会把新闻内容派发给所有的订阅者(Reader),Reader是实现了Observer接口的类表示读者。

Observable的简单功能介绍：
addObserver(Observer o) 添加观察着
clearChanged() 清除变化，则把“变化标志”设为false
countObservers() 统计观察着数量
deleteObserver(Observer o) 删除观察者
deleteObservers() 删除所有的观察者
hasChanged() 测试是否有变化(则返回“变化标志”)
notifyObservers() 如果hasChanged()=ture，通知所有的观察着(则调用Observer.update()方法)
notifyObservers(Object arg) 如果hasChanged()=ture，通知所有的观察着(则调用Observer.update()方法),并把参数arg传过去
setChanged() 设置变化，则把“变化标志”设为true

Observable的简单功能介绍
update(Observable o, Object arg) Observable唯一的方法，在被通知时被Observable调用

例子代码：
Java代码

package com.pasu.observer;   

import java.util.Observable;   

public class NewsDispatcher extends Observable   
{   

    public void addNews(String news)   
    {   
        this.setChanged();   
        this.notifyObservers(news);   
    }   
}  

Java代码

package com.pasu.observer;   

import java.util.Observable;   
import java.util.Observer;   

public class Reader implements Observer   
{   
    private String name;   

    public Reader(String name)   
    {   
        this.name = name;   
    }   

    @Override  
    public void update(Observable o, Object arg)   
    {   
        String news = (String)arg;   
        System.out.println(name + " : " + news);   
    }   


}  

Java代码

package com.pasu.observer;   

public class Test   
{   
    public static void main(String[] args)   
    {   
        //体育新闻派发器   
        NewsDispatcher sportNewsDispatcher = new NewsDispatcher();   
        //it新闻派发器   
        NewsDispatcher itNewsDispatcher = new NewsDispatcher();   
        //观察者r1,r2,r3   
        Reader r1 = new Reader("r1");   
        Reader r2 = new Reader("r2");   
        Reader r3 = new Reader("r3");   
        //添加观察者   
        sportNewsDispatcher.addObserver(r1);   
        sportNewsDispatcher.addObserver(r2);   
        itNewsDispatcher.addObserver(r3);   
        //当有新的新闻的时候，通知观察者   
        sportNewsDispatcher.addNews("中国队突破了历史获得了世界杯冠军!");   
        itNewsDispatcher.addNews("ibm 收购 sun公司，java开始收费!");    
    }   
}  

Test类运行输出的结果
Java代码
r2 : 中国队突破了历史，获得了世界杯冠军!
r1 : 中国队突破了历史，获得了世界杯冠军!
r3 : ibm 收购 sun公司，java开始收费!

因为Observable是一个类而不是一个接口，这就成了一个大问题。因为java不支持多继承。