观察者模式（Observer）

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

主题和观察者定义了一对多的关系，观察者依赖于主题。当主题对象的状态发生改变时，观察者就会被通知。根据通知观察者进行相关操作。

　一、　涉及角色：主题接口，观察者接口，具体主题，具体观察者。

     

    

优点：主题是真正拥有数据的对象，观察者是主题的依赖者，在数据变化跟新时这样比多个对象控制同一份数据，可以更干净的OO设计。

缺点：并不是所有的观察者都需要这份数据，有可能只需要其中的一部分，却接收了一堆数据。（JDK中的观察这模式，提供了支持，支持以个getter方法的主动获取数据）

二、代码实例

     (1)抽象观察者角色

public interface Observer {
    /**
     * <p>观察者对象更新自己的信息</p>
     * @author maxianming 2016-1-11 下午2:11:44
     * @param Message
     */
    public void update(String Message);
}

     (2)抽象主题角色

  

public interface Subject {
    /**
     * <p>主题对象中注册一个观察者</p>
     * @author maxianming 2016-1-11 下午2:09:17
     * @param observer
     */
    public void registerObserver(Observer observer);
    /**
     * <p>主题对象中删除一个观察者</p>
     * @author maxianming 2016-1-11 下午2:09:53
     * @param observer
     */
    public void removeObserver(Observer observer);
    /**
     * <p>主题对象改变通知所有的观察者对象</p>
     * @author maxianming 2016-1-11 下午2:11:05
     */
    public void notifyObservers();
}

     (3)具体观察者角色

public class ConcreteObserver implements Observer {
    private Subject subject;
    
    public ConcreteObserver(Subject subject){
        this.subject = subject;
        subject.registerObserver(this);
    }
    
    @Override
    public void update(String message) {
         System.out.println("具体观察者得到 【主题对象的信息】为:" + message);        
    }
    
}

     (4)具体主题角色

public class ConcreteSubject implements Subject {
    private ArrayList<Observer> observers;
    private String message;
    
    public ConcreteSubject(){
        this.observers = new ArrayList<Observer>();
    }
    @Override
    public void registerObserver(Observer observer) {
        this.observers.add(observer);
    }
    
    @Override
    public void removeObserver(Observer observer) {
        boolean hasObserver = this.observers.contains(observer);
        if(hasObserver){
            this.observers.remove(observer);
        }
    }
    
    @Override
    public void notifyObservers() {
        for (int i = 0; i < observers.size(); i++) {
            Observer observer = observers.get(i);
            if(observer != null){
                observer.update(this.message);
            }
            
        }
    }
    
    public void setData(String message){
        this.message = message;
        //状态改变，通知观察者
        this.notifyObservers();
    }
}

     (5)客户端

public class Client {
    public static void main(String[] args) {
        //1、主题对象
        ConcreteSubject subject = new ConcreteSubject();
        //2、观察者对象
        Observer observer = new ConcreteObserver(subject);
        //3、主题对象信息改变
        subject.setData("213123213");
        
        //4、删除观察者对象
        subject.removeObserver(observer);
        //5、主题对象信息gaibian
        subject.setData("3456178");
    }
}

三、JDK中观察者模式

    JDK对观察者模式提供了支持。主题类Observable，具体主题类可以继承JDK中实现类Observable类。具体观察者可以实现JDK中的观察者接口Observer接口。

    主题通知观察者：继承JDKObservable的主题接口，通知观察者对象步骤。

    （1）先调用Observable中的setChanged（）方法。标记状态已经改变

    （2）再调用notifyObservers（）或notifyObservers（arg）（带参数方法可以推送指定的参数）。