設計模式--觀察者模式

1、觀察者模式

觀察者模式：定義對象間一種一對多的依賴關係，當一個對象狀態發生變化時，所有依賴於它的對象都得到通知，並被自動更新。

2、觀察者模式的結構

• 角色

  • 主題（Subject）:主題是一個介面，該介面規定了具體主題需要實現的方法，比如添加，刪除觀察者以及通知觀察者的方法。

  • 觀察者（ObServer）: 觀察者是一個介面，該介面規定了具體觀察者用來獲得數據的方法。

  • 具體主題（ConcreteSubject）:具體主題是實現主題介面的類的一個實例，該實例包含觀察者關心的數據，而且這些數據可能經常發生變化。具體主題需要使用一個集合來存放觀察者的引用，以便數據變化時通知具體的觀察者。

  • 具體觀察者（ConreteObserver）:具體觀察者是實現觀察者介面的類的一個實例。具體觀察者包含具體主題的引用，以便讓具體主題將自己添加到具體主題的集合中，使自己成為具體主題的觀察者，或者從具體主題的集合中將自己刪除，不成為具體主題的觀察者。

• UML圖

3、觀察者模式舉例

　主題介面：Subject.java

 1 package com.nick.pattern.observer;
 2 
 3 import java.util.ArrayList;
 4 
 5 /**
 6  * @ 主題介面:定義了觀察者數組（存放觀察者的信息）和抽象方法
 7  * @author nick
 8  *
 9  */
10 public interface Subject {　　
11    ArrayList<Observer> observers =null;
12　　 void attach(Observer obs); 
13    void detach(Observer obs); 
14    void cry();　　//相當於notify()通知方法 
15 }

 觀察者介面：Observer.java

1 package com.nick.pattern.observer;
2 /**
3  * @ 觀察者介面
4  * @author nick
5  */
6 public interface Observer {
7     void response();　//相當於update()方法　
8 }

 具體主題類：Cat.java

 1 package com.nick.pattern.observer;
 2 
 3 import java.util.ArrayList;
 4 
 5 /**
 6  * @ 具體主題：貓（老鼠和狗是觀察者，他們通過觀察貓的行為，做出反應）
 7  * @author nick
 8  *
 9  */
10 public class Cat implements Subject {
11     ArrayList<Observer> observers = new ArrayList<Observer>();
12     
13     @Override
14     public void attach(Observer obs) {
15         observers.add(obs);
16     }
17 
18     @Override
19     public void detach(Observer obs) {
20         observers.remove(obs);    
21     }
22 
23     @Override
24     public void cry() {    //通知方法
25         System.out.print("貓叫:");
26         System.out.println("喵喵喵");
27         for(Observer obs:observers) {
28             obs.response();
29         }
30     }
31 }

具體觀察者：Dog.java

 1 package com.nick.pattern.observer;
 2 /**
 3  * @ 具體觀察者: 狗
 4  * @author nick
 5  *
 6  */
 7 public class Dog  implements Observer{
 8 
 9     @Override
10     public void response() {
11         System.out.print("狗叫：");
12         System.out.println("汪汪汪");
13     }
14 
15 }

具體觀察者：Mouse.java

 1 package com.nick.pattern.observer;
 2 /**
 3  * @ 具體觀察者：老鼠
 4  * @author nick
 5  *
 6  */
 7 public class Mouse implements Observer{
 8 
 9     @Override
10     public void response() {
11         System.out.print("老鼠跑：");
12         System.out.println("跑跑跑");
13     }
14 
15 }

主程式：Application.java

 1 package com.nick.pattern.observer;
 2 /**
 3  * @ 主程式
 4  * @author nick
 5  *
 6  */
 7 public class Application {
 8 
 9     public static void main(String[] args) {
10             Subject cat = new Cat();
11             Observer dog = new Dog();
12             Observer mouse = new Mouse();
13             cat.attach(dog);
14             cat.attach(mouse);
15             
16             cat.cry();//觸發通知方法
17     }
18 
19 }

運行結果：

 4、觀察者模式的優缺點

• 優點1： 具體主題和觀察者是松耦合的關係。由於主題介面僅僅依賴與觀察者介面，因此具體主題只是知道他的觀察者是實現觀察者介面的某個類的實例，但不需要知道是哪個類。
• 優點2：具體觀察者只需要知道它依賴的主題是實現主題介面的某個實例即可，不需要知道具體是哪個類。
• 優點3：觀察者模式滿足“開-閉”原則。主題介面(Subject)僅僅依賴於觀察者介面（Observer）。這樣具體主題的類也僅僅依賴於觀察者介面，增加新的實現觀察者介面的類，不必修改創建具體主題的類的代碼：
  • 　　新增加一個觀察者Pig.java

  •  1 package com.nick.pattern.observer;
     2 /**
     3  * @ 新增的觀察者Pig
     4  * @author nick
     5  */
     6 public class Pig implements Observer{
     7 
     8     @Override
     9     public void response() {
    10         System.out.println("豬叫：");
    11         System.out.println("咯咯咯");
    12     }
    13 
    14 }

  • 只需要在主程式中添加這兩行代碼
  • 
  •