【正文】
一、觀察者模式的定義：
簡單地說，觀察者模式定義了一個一對多的依賴關系，讓一個或多個觀察者對象監聽一個主題對象。這樣一來，當被觀察者狀態發生改變時，需要通知相應的觀察者，使這些觀察者對象能夠自動更新。例如：GUI中的事件處理機制采用的就是觀察者模式。
二、觀察者模式的實現：
Subject（被觀察的對象接口）:規定ConcreteSubject的統一接口 ; 每個Subject可以有多個Observer；ConcreteSubject（具體被觀察對象）:維護對所有具體觀察者的引用的列表 ；–狀態發生變化時會發送通知給所有注冊的觀察者。Observer（觀察者接口）:規定ConcreteObserver的統一接口；定義了一個update()方法，在被觀察對象狀態改變時會被調用。ConcreteObserver（具體觀察者）:維護一個對ConcreteSubject的引用；特定狀態與ConcreteSubject同步；實現Observer接口，update()方法的作用：一旦檢測到Subject有變動，就更新信息。
圖表描述如下：
注：在被觀察者類中需要有一個集合維護所有觀察者。
三、舉例說明：
【方案一】：自己定義接口或者類來實現觀察者模式。
步驟如下：
（1）定義被觀察者所具有的接口：
|
1
2
3
4
5
6
7
8
9
10
11
|
package com.vince.observer;public interface Observable { //注冊為一個觀察者 public void registerObserver(Observer observer); //取消觀察者 public void removeObserver(Observer observer); //通知所有觀察者更新信息 public void notifyObservers();} |
（2）定義具體的被觀察者：杯子
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
package com.vince.observer;import java.util.Vector;public class Cup implements Observable{ //被觀察者維護的一個觀察者對象列表 private Vector<Observer> vector = new Vector<Observer>(); private float price; public Cup(float price){ this.price = price; } public float getPrice() { return price; } public void setPrice(float price) { //修改價格時，通知所有觀察者 this.price = price; notifyObservers(); } @Override public void registerObserver(Observer observer) { //注冊觀察者 vector.add(observer); } @Override public void removeObserver(Observer observer) { //取消觀察者 vector.remove(observer); } @Override public void notifyObservers() { //實現通知所有的觀察者對象 for (Observer observer:vector) { observer.update(price); } }} |
（3）定義觀察者所具有的共同的接口：（更新數據最終當然是在觀察者那里進行啦）
|
1
2
3
4
5
6
7
|
package com.vince.observer;public interface Observer { public void update(float price);5} |
（4）定義具體的觀察者對象：
|
1
2
3
4
5
6
7
8
9
10
11
|
package com.vince.observer;public class Person implements Observer{ private String name; public Person(String name){ this.name = name; } @Override public void update(float price) { System.out.println(name+"關注的杯子的價格已更新為："+price); }} |
（5）測試：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
package com.vince.observer;public class Test { public static void main(String[] args) { //創建一個被觀察者對象 Cup doll = new Cup(3000); //創建兩個觀察者對象 Person p1 = new Person("生命壹號"); Person p2 = new Person("生命貳號"); //注冊成為一個觀察者 doll.registerObserver(p1); doll.registerObserver(p2); System.out.println("第一輪促銷："); doll.setPrice(2698);// 價格變動 System.out.println("第二輪促銷："); doll.setPrice(2299);// System.out.println("第三輪促銷："); doll.setPrice(1998); doll.removeObserver(p2); //將生命二號移除 System.out.println("第四輪促銷："); doll.setPrice(1098); }} |
運行后，顯示結果如下：
【方案二】：直接調用JDK的API去實現。
步驟如下：
（1） 通過繼承Observable類實現具體的被觀察者對象：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package com.vince.observer2;import java.util.Observable;public class Cup extends Observable{ private float price; public Cup(float price){ this.price = price; } public float getPrice() { return price; } public void setPrice(float price) { this.price = price; this.setChanged();//通知，數據已改變 this.notifyObservers(); } } |
（2）通過實現java.util.Observer接口實現具體的觀察者對象：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
package com.vince.observer2;import java.util.Observable;import java.util.Observer;public class Person implements Observer{ private String name; public Person(String name){ this.name = name; } @Override public void update(Observable o, Object arg) { if(o instanceof Cup){ Cup cup = (Cup)o; System.out.println(name+"關注的杯子價格已更新為："+cup.getPrice()); } }} |
（3）測試：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
package com.vince.observer2;public class Test { public static void main(String[] args) { Cup cup = new Cup(3000); Person p1 = new Person("生命壹號"); Person p2 = new Person("生命貳號"); cup.addObserver(p1); cup.addObserver(p2); System.out.println("第一輪促銷"); cup.setPrice(2988); System.out.println("第二輪促銷"); cup.setPrice(2698); cup.deleteObserver(p2); System.out.println("第三輪促銷"); cup.setPrice(1998); }} |
運行后，結果如下：
【工程文件】
四、總結：（觀察者模式的作用）
觀察者模式在被觀察者和觀察者之間建立一個抽象的耦合。被觀察者角色所知道的只是一個具體觀察者列表。
由于被觀察者和觀察者沒有緊密地耦合在一起，因此它們可以屬于不同的抽象化層次。如果被觀察者和觀察者都被扔到一起，那么這個對象必然跨越抽象化和具體化層次。
觀察者模式支持廣播通訊。被觀察者會向所有的登記過的觀察者發出通知。
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持服務器之家。
原文鏈接：http://www.cnblogs.com/smyhvae/p/3899208.html
