觀察者模式：定義了一種一對多的依賴關(guān)系，讓多個(gè)觀察者對象同時(shí)監(jiān)聽某一個(gè)主題對象。這個(gè)主體對象在狀態(tài)發(fā)生變化時(shí)，會(huì)通知所有觀察者對象，使它們能夠自動(dòng)更新自己。

觀察者模式結(jié)構(gòu)圖

什么時(shí)候使用觀察者模式：當(dāng)一個(gè)對象的改變需要同時(shí)改變其他對象的時(shí)候，而且它不知道具體有多少對象有待改變時(shí)，應(yīng)該考慮使用觀察者模式。
觀察者模式所做的工作其實(shí)就是在解除耦合。讓耦合的雙方都依賴抽象，而不是依賴于具體。

全部自定義實(shí)現(xiàn)的觀察者模式

package com.observer;
//被觀察對象的接口
public interface Subject {
    //add observer
    public void add(Observer o);
    public void del(Observer o);
    //通知所有觀察者
    public void notifyObservers();
    //被觀察對象的一些操作
    public void operation();
}

package com.observer;

import java.util.Iterator;
import java.util.Vector;

public class AbstractSubject implements Subject {
    private Vector<Observer> vector = new Vector<Observer>();
    @Override
    public void add(Observer o) {
        vector.add(o);
    }

    @Override
    public void del(Observer o) {
        vector.remove(o);
    }

    @Override
    public void notifyObservers() {
        Iterator i = vector.iterator();
        while(i.hasNext()){
            Observer o = (Observer)i.next();
            o.update();
        }
    }

    @Override
    public void operation() {
    }
}

package com.observer;

public class MySubject extends AbstractSubject {

    @Override
    public void operation() {
        super.operation();
        System.out.println("被觀察者變化：");
        this.notifyObservers();
    }
}

package com.observer;
//觀察者接口
public interface Observer {
    public void update();
}

package com.observer;

public class Observer1 implements Observer {
    @Override
    public void update() {
        System.out.println("observer1 update");
    }
}

package com.observer;

public class Observer2 implements Observer {
    @Override
    public void update() {
        System.out.println("observer2 update");
    }
}

package com.observer;
/**
 * ClassName: Main 
 * @Description:觀察者模式（Observer）：
 * 當(dāng)一個(gè)對象變化時(shí)，其它依賴該對象的對象都會(huì)收到通知，并且隨著變化！對象之間是一種一對多的關(guān)系。
 * MySubject類就是我們的主對象，Observer1和Observer2是依賴于MySubject的對象，
 * 當(dāng)MySubject變化時(shí)，Observer1和Observer2必然變化。AbstractSubject類中定義著需要監(jiān)控的對象列表，
 * 可以對其進(jìn)行修改：增加或刪除被監(jiān)控對象，且當(dāng)MySubject變化時(shí)，負(fù)責(zé)通知在列表內(nèi)存在的對象。 
 * @author Panyk
 * @date 2015年10月14日
 */
public class Main {
    public static void main(String[] args) {
        Subject s = new MySubject();
        s.add(new Observer1());
        s.add(new Observer2());
        s.operation();
    }
}

利用jdk實(shí)現(xiàn)的觀察者模式

package com.observer;

import java.util.Observable;
import java.util.Observer;
/**
 * ClassName: Reception 
 * @Description: 前臺(tái)妹子類
 * @author Panyk
 * @date 2016年3月23日
 */
public class Reception extends Observable {
    String action = "";
    @Override
    public synchronized void addObserver(Observer o) {
        super.addObserver(o);
    }

    @Override
    public synchronized void deleteObserver(Observer o) {
        super.deleteObserver(o);
    }

    @Override
    public void notifyObservers() {
        super.notifyObservers();
    }

    @Override
    public String toString() {
        return "Reception [action=" + action + "]";
    }

    public String getAction() {
        return action;
    }

    public void setAction(String action) {
        this.setChanged();//必須先setChanged，否則notifyObservers不起作用。
        this.action = action;
        this.notifyObservers(1);//這里的參數(shù)會(huì)傳遞給觀察者
        System.out.println("notifyObservers之后，自動(dòng)置為了false，再次notifyObservers不起作用。" + this.hasChanged());
        this.notifyObservers();
    }
}

package com.observer;

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

public class Programer implements Observer {
    String name = "";
    
    public Programer(String name) {
        this.name = name;
    }
    @Override
    public void update(Observable o, Object arg) {//o是被觀察者對象，arg是被觀察者傳遞過來的變量
        System.out.println("--------------");
        System.out.println(name);
        System.out.println(o);
        System.out.println(arg);
    }
}

package com.observer;

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

public class Main {

    public static void main(String[] args) {
        Observer p1 = new Programer("zhangsan1");
        Observer p2 = new Programer("zhangsan2");
        Observer p3 = new Programer("zhangsan3");
        Observer p4 = new Programer("zhangsan4");
        Observer p5 = new Programer("zhangsan5");
        
        Reception r = new Reception();
        r.addObserver(p1);
        r.addObserver(p2);
        r.addObserver(p3);
        r.addObserver(p4);
        r.addObserver(p5);
        r.setAction("哈哈");
        
    }
}

//輸出結(jié)果
--------------
zhangsan5
Reception [action=哈哈]
1
--------------
zhangsan4
Reception [action=哈哈]
1
--------------
zhangsan3
Reception [action=哈哈]
1
--------------
zhangsan2
Reception [action=哈哈]
1
--------------
zhangsan1
Reception [action=哈哈]
1
notifyObservers之后，自動(dòng)置為了false，再次notifyObservers不起作用。false