观察者模式

定义：当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使他们能够自动更新自己。类似于事件，发生一个事件时，所有监听该事件的观察者会自动更新（或者说调用自身某些方法）。
结构图：

角色：
1.抽象目标角色（Subject）：目标角色知道它的观察者，可以有任意多个观察者观察同一个目标。并且提供注册和删除观察者对象的接口。目标角色往往由抽象类或者接口来实现。
2.抽象观察者角色（Observer）：为那些在目标发生改变时需要获得通知的对象定义一个更新接口。抽象观察者角色主要由抽象类或者接口来实现。
3.具体目标角色（Concrete Subject）：将有关状态存入各个Concrete Observer对象。当它的状态发生改变时, 向它的各个观察者发出通知。自身维护一个观察者容器并提供添加、删除观察者接口。
4.具体观察者角色（Concrete Observer）：存储有关状态，这些状态应与目标的状态保持一致。实现Observer的更新接口以使自身状态与目标的状态保持一致。在本角色内也可以维护一个指向Concrete Subject对象的引用。

优点：

1、观察者和被观察者是抽象耦合的。

2、建立一套触发机制。

缺点：

1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。

2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。

3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

使用：

abstract class Subject 
{  
    private Vector<Observer> obs = new Vector<Observer>();  
      
    public void addObserver(Observer obs)
    {  
        this.obs.add(obs);  
    }  

    public void delObserver(Observer obs)
    {  
        this.obs.remove(obs);  
    }  

    protected void notifyObserver()
   {  
        for(Observer o: obs){  
            o.update();  
        }  
    }  
    public abstract void doSomething();  
} 
 
  class ConcreteSubject extends Subject 
{  
    public void doSomething()
   {  
        System.out.println("被观察者事件反生");  
        this.notifyObserver();  
    }  
}
  
interface Observer 
{  
    public void update();  
}
  
class ConcreteObserver1 implements Observer 
{  
    public void update() 
    {  
        System.out.println("观察者1收到信息，并进行处理。");  
    }  
}
  
class ConcreteObserver2 implements Observer 
{  
    public void update() 
    {  
        System.out.println("观察者2收到信息，并进行处理。");  
    }  
}  
  
public class Client 
{  
    public static void main(String[] args)
   {  
        Subject sub = new ConcreteSubject();  
        sub.addObserver(new ConcreteObserver1()); //添加观察者1  
        sub.addObserver(new ConcreteObserver2()); //添加观察者2  
        sub.doSomething();  
    }  
}