Java設計模式之觀察者模式

摘要： 1、初步認識： 策略模式的定義： 定義一組演算法，將每個演算法都封裝起來，使得它們之間可以相互替換。策略模式讓演算法獨立於呼叫它的客戶端而獨立變化。 大白話： 我清楚知道自己身上有幾把武器（策略），我會根據不同的情況使用不同的武器（根據情況，切換策略）。 遊戲中我分別撿到三...

1、初步認識：

策略模式的定義：

定義一組演算法，將每個演算法都封裝起來，使得它們之間可以相互替換。策略模式讓演算法獨立於呼叫它的客戶端而獨立變化。

大白話：

我清楚知道自己身上有幾把武器（策略），我會根據不同的情況使用不同的武器（根據情況，切換策略）。

遊戲中我分別撿到三把槍：

1、R1895消音左輪一把；

2、S12K霰彈槍（五連噴）一把；

3、AWM狙擊步槍一把；

1、初步認識

觀察者模式的定義：

在物件之間定義了一對多的依賴，這樣一來，當一個物件改變狀態，依賴它的物件會收到通知並自動更新。

大白話：

其實就是釋出訂閱模式，釋出者釋出資訊，訂閱者獲取資訊，訂閱了就能收到資訊，沒訂閱就收不到資訊。

2、這個模式的結構圖

3、可以看到，該模式包含四個角色

• 抽象被觀察者角色 ：也就是一個抽象主題，它把所有對觀察者物件的引用儲存在一個集合中，每個主題都可以有任意數量的觀察者。抽象主題提供一個介面，可以增加和刪除觀察者角色。一般用一個抽象類和介面來實現。
• 抽象觀察者角色 ：為所有的具體觀察者定義一個介面，在得到主題通知時更新自己。
• 具體被觀察者角色 ：也就是一個具體的主題，在集體主題的內部狀態改變時，所有登記過的觀察者發出通知。
• 具體觀察者角色 ：實現抽象觀察者角色所需要的更新介面，一邊使本身的狀態與製圖的狀態相協調。

4、使用場景例子

有一個微信公眾號服務，不定時釋出一些訊息，關注公眾號就可以收到推送訊息，取消關注就收不到推送訊息。

5、觀察者模式具體實現

1、定義一個抽象被觀察者介面

package com.jstao.observer;

/***
 * 抽象被觀察者介面
 * 聲明瞭新增、刪除、通知觀察者方法
 * @author jstao
 *
 */
public interface Observerable {

public void registerObserver(Observer o);
public void removeObserver(Observer o);
public void notifyObserver();

}

2、定義一個抽象觀察者介面

package com.jstao.observer;

/***
 * 抽象觀察者
 * 定義了一個update()方法，當被觀察者呼叫notifyObservers()方法時，觀察者的update()方法會被回撥。
 * @author jstao
 *
 */
public interface Observer {
public void update(String message);
}

3、定義被觀察者，實現了Observerable介面，對Observerable介面的三個方法進行了具體實現，同時有一個List集合，用以儲存註冊的觀察者，等需要通知觀察者時，遍歷該集合即可。

package com.jstao.observer;

import java.util.ArrayList;
import java.util.List;

/**
 * 被觀察者，也就是微信公眾號服務
 * 實現了Observerable介面，對Observerable介面的三個方法進行了具體實現
 * @author jstao
 *
 */
public class WechatServer implements Observerable {

//注意到這個List集合的泛型引數為Observer介面，設計原則：面向介面程式設計而不是面向實現程式設計
private List<Observer> list;
private String message;

public WechatServer() {
list = new ArrayList<Observer>();
}

@Override
public void registerObserver(Observer o) {

list.add(o);
}

@Override
public void removeObserver(Observer o) {
if(!list.isEmpty())
list.remove(o);
}

//遍歷
@Override
public void notifyObserver() {
for(int i = 0; i < list.size(); i++) {
Observer oserver = list.get(i);
oserver.update(message);
}
}

public void setInfomation(String s) {
this.message = s;
System.out.println("微信服務更新訊息： " + s);
//訊息更新，通知所有觀察者
notifyObserver();
}

}

4、定義具體觀察者，微信公眾號的具體觀察者為使用者User

package com.jstao.observer;

/**
 * 觀察者
 * 實現了update方法
 * @author jstao
 *
 */
public class User implements Observer {

private String name;
private String message;

public User(String name) {
this.name = name;
}

@Override
public void update(String message) {
this.message = message;
read();
}

public void read() {
System.out.println(name + " 收到推送訊息： " + message);
}

}

5、編寫一個測試類

首先註冊了三個使用者，ZhangSan、LiSi、WangWu。公眾號釋出了一條訊息"PHP是世界上最好用的語言！"，三個使用者都收到了訊息。

使用者ZhangSan看到訊息後頗為震驚，果斷取消訂閱，這時公眾號又推送了一條訊息，此時使用者ZhangSan已經收不到訊息，其他使用者

還是正常能收到推送訊息。

package com.jstao.observer;

public class Test {

public static void main(String[] args) {
WechatServer server = new WechatServer();

Observer userZhang = new User("ZhangSan");
Observer userLi = new User("LiSi");
Observer userWang = new User("WangWu");

server.registerObserver(userZhang);
server.registerObserver(userLi);
server.registerObserver(userWang);
server.setInfomation("PHP是世界上最好用的語言！");

System.out.println("----------------------------------------------");
server.removeObserver(userZhang);
server.setInfomation("JAVA是世界上最好用的語言！");

}
}

測試結果：

6、小結

• 這個模式是鬆偶合的。改變主題或觀察者中的一方，另一方不會受到影像。
• JDK中也有自帶的觀察者模式。但是被觀察者是一個類而不是介面，限制了它的複用能力。
• 在JavaBean和Swing中也可以看到觀察者模式的影子。

0;">   現在我知道我身上是背有三把槍的， 然後我就可以根據敵人與我的距離切換使用合適的槍（根據情況，使用不同的策略）。

突然發現八百米開外有個敵人，我摸出AWM狙擊步槍（有目的的切換武器），

  算好風速，調整好姿勢，“彭”，一發入魂，敵人應聲倒下。

  接著，又發現左前方有個敵人，我切換到S12K霰彈槍（有目的切換武器，切換策略），悄悄向右前方摸了過去，“突突突”

五連發，遊戲結束。

2、策略模式的結構圖：

3、可以看到，該模式包含三個角色：

• 抽象策略(Strategy)： 通常由介面或抽象類實現。定義了多個具體策略的公共介面，具體策略類中各種不同的演算法以不同的方式實現這個介面；Context使用這些介面呼叫不同實現的演算法。
• 具體策略(ConcreteStrategy)： 實現Strategy介面或繼承於抽象類Strategy，封裝了具體的演算法和行為。
• 環境類(Contex)： 持有一個公共策略介面的引用，直接給客戶端呼叫。

4、使用場景例子：

玩槍戰類遊戲，可以根據不同戰場情況，切換槍支。

5、策略模式具體實現：

（1）給策略物件（槍）定義一個公共介面

1 public interface Weapon {
2public void gun();
3 }

（2）定義具體的策略類(ConcreteStrategy)，實現上面的介面

public class FirstGun implements Weapon {

@Override
public void gun() {
System.out.println("使用AWM狙擊步槍。");
}

}

public class SecondGun implements Weapon {

@Override
public void gun() {
System.out.println("使用S12K霰彈槍。");
}

}

(3)定義一個環境類（Contex），類中持有一個對公共介面的引用，以及相應的get、set方法、構造方法

public class Context {
Weapon weapon;

public Context(Weapon weapon) { //建構函式
super();
this.weapon = weapon;
}

public Weapon getWeapon() { //get方法
return weapon;
}

public void setWeapon(Weapon weapon) { //set方法
this.weapon = weapon;
}

public void gun() {
weapon.gun();
}
}

最後，客戶端自由呼叫策略（我在槍林彈雨的戰場上，切換武器，擊斃敵人）

public class StrategyClient {

public static void main(String[] args) {
//使用建構函式預設選擇一把AWM狙擊步槍（一個策略）
Context context=new Context(new FirstGun());
context.gun();

//使用get、set方法切換到S12K霰彈槍（切換策略）
　　　　 System.out.println("------右前方30米發現敵人------");
contex.set(new SecondGun());
context.gun();
}
}

輸出結果：

5、策略模式，小結一下：

• 重點 在於： 給物件傳入什麼樣的策略，就執行什麼樣的動作。
• 優點在於： 可以輕易的擴充套件與改變策略，可以動態改變物件的行為。
• 缺點在於： 客戶端必須知道所有的策略類，並自行決定使用哪一種。每個具體的策略都會產生一個新類，這樣會造成很多策略類。

Linux公社的RSS地址 ： https://www.linuxidc.com/rssFeed.aspx

本文永久更新連結地址： https://www.linuxidc.com/Linux/2019-02/156802.htm