该模式定义了一个一对多的关系，一个被观察对象与一群观察对象存在依赖关系，一旦这个被观察对象有什么风吹草动，其他的观察者就都能收到通知。其实本质是被观察对象通知所有观察者对象。
软件系统很多时候需要这样的情况，一旦发生故障，就通知对应的系统或模块，使之能够及时处理。
观察者类图结构
- 抽象主题 Subject：提供添加和减少观察者方法和通知观察者方法；
- 具体主题 ConcreteSubject：对抽象主题的实现，包含一个观察者的集合[这里是接口哦，我们是针对接口编程的]，用以操作与观察者之间的互动；
- 抽象观察者 Observer：提供被主题调用的方法，一旦主题变动，就调用这个方法；
- 具体观察者 ConcreteObserver：对抽象观察者的抽象调用方法进行实现。
有了上面的类图，很快就把代码切出来：
public interface Subject {
public void attach(Observer observer);
public void detach(Observer observer);
public void notifyObservers();
}
以上就是抽象主题的基本代码，大抵上可以完成任务了
public interface Observer {
public void update();
}
抽象观察者，这里简化，只有一个公开方法被主题调用
接下来把具体的主题构造出来，如下所示
import java.util.ArrayList;
import java.util.List;
public class ConcreteSubject implements Subject{
//装载所有观察者的容器
private List<Observer> observers=null;
//构造方法里面初始化容器
public ConcreteSubject() {
observers=new ArrayList<Observer>();
}
@Override
public void attach(Observer observer) {
if(!observers.contains(observer)){
observers.add(observer);
}
}
@Override
public void detach(Observer observer) {
if(observers.contains(observer)){
observers.remove(observer);
}
}
@Override
public void notifyObservers() {
for(Observer observer:observers){
observer.update();
}
}
}
其主要任务就是绑定和解绑观察者，以及有事通知观察者，当然可以对观察者进行分类，根据分类再进行通知。
最后是具体的观察者，主要工作代码如下
public class ConcreteObserver implements Observer{
private String name;
public ConcreteObserver(String name) {
this.name=name;
}
@Override
public void update() {
System.out.println(this.name+"被调用了，在时间："+new Date());
}
}
运行下来看看
public class Client {
public static void main(String[] args) {
Observer o1=new ConcreteObserver("张三");
Observer o2=new ConcreteObserver("李四");
Subject subject=new ConcreteSubject();
subject.attach(o1);
subject.attach(o2);
subject.notifyObservers();
subject.detach(o2);
subject.notifyObservers();
}
}
非常完美的实现了主题通知观察者。需要注意的是，在具体主题里面的集合容器最好不要使得外界可以修改，以及线程安全方面需要考虑。
另外一种方式把主题作为抽象类，然后关联到抽象观察者，而具体主题负责把状态改变后，调用抽象的通知方法；
来段代码实际情况看看；
import java.util.ArrayList;
import java.util.List;
public abstract class AbstractSubject {
// 装载所有观察者的容器
private List<Observer> observers = null;
// 构造方法里面初始化容器
public AbstractSubject() {
observers = new ArrayList<Observer>();
}
public void attach(Observer observer) {
if (!observers.contains(observer)) {
observers.add(observer);
}
}
public void detach(Observer observer) {
if (observers.contains(observer)) {
observers.remove(observer);
}
}
public void notifyObservers() {
for (Observer observer : observers) {
observer.update();
}
}
//具体主题务必实现这个方法
protected String state;
public abstract void change(String newState);
}
这个抽象主题比较能干，把子类要做到事多包揽了，子类的工作就轻松多了，来看下
public class ConcreteSubject2 extends AbstractSubject{
@Override
public void change(String newState) {
this.state=newState;
System.out.println("当前主题状态修改为"+this.state);
notifyObservers();
}
}
具体主题就实现了一个方法，顿时轻松，观察者和上面一样，来看下客户端怎么使用
public class Client {
public static void main(String[] args) {
Observer o1=new ConcreteObserver("张三");
Observer o2=new ConcreteObserver("李四");
// Subject subject=new ConcreteSubject();
// subject.attach(o1);
// subject.attach(o2);
// subject.notifyObservers();
// subject.detach(o2);
// subject.notifyObservers();
AbstractSubject subject=new ConcreteSubject2();
subject.attach(o1);
subject.attach(o2);
subject.change("A");
subject.detach(o2);
subject.change("B");
}
}
JDK 自带了观察者模式的一些基本类，可以使用，但最好还是自己造一个更方便，里面的源码可以借鉴看看，考虑的很详细。
