Java開發中的23種設計模式詳解之三：11種行為型模式
本章是關於設計模式的最後一講，會講到第三種設計模式——行為型模式，共11種：策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、直譯器模式。這段時間一直在寫關於設計模式的東西，終於寫到一半了，寫博文是個很費時間的東西，因為我得為讀者負責，不論是圖還是程式碼還是表述，都希望能儘量寫清楚，以便讀者理解，我想不論是我還是讀者，都希望看到高質量的博文出來，從我本人出發，我會一直堅持下去，不斷更新，源源動力來自於讀者朋友們的不斷支援，我會盡自己的努力，寫好每一篇文章！希望大家能不斷給出意見和建議，共同打造完美的博文！
先來張圖，看看這11中模式的關係：
第一類：通過父類與子類的關係進行實現。第二類：兩個類之間。第三類：類的狀態。第四類：通過中間類
13、策略模式（strategy）
策略模式定義了一系列演算法，並將每個演算法封裝起來，使他們可以相互替換，且演算法的變化不會影響到使用演算法的客戶。需要設計一個介面，為一系列實現類提供統一的方法，多個實現類實現該介面，設計一個抽象類（可有可無，屬於輔助類），提供輔助函式，關係圖如下：
圖中ICalculator提供同意的方法，
AbstractCalculator是輔助類，提供輔助方法，接下來，依次實現下每個類：
首先統一介面：
- public interface ICalculator {
- public int calculate(String exp);
- }
輔助類：
- public abstract class AbstractCalculator {
- public int[] split(String exp,String opt){
- String array[] = exp.split(opt);
- int arrayInt[] = new int[2];
- arrayInt[0] = Integer.parseInt(array[0]);
- arrayInt[1] = Integer.parseInt(array[1]);
- return arrayInt;
- }
- }
三個實現類：
- public class Plus extends AbstractCalculator implements ICalculator {
- @Override
- public int calculate(String exp) {
- int arrayInt[] = split(exp,"\\+");
- return arrayInt[0]+arrayInt[1];
- }
- }
- public class Minus extends AbstractCalculator implements ICalculator {
- @Override
- public int calculate(String exp) {
- int arrayInt[] = split(exp,"-");
- return arrayInt[0]-arrayInt[1];
- }
- }
- public class Multiply extends AbstractCalculator implements ICalculator {
- @Override
- public int calculate(String exp) {
- int arrayInt[] = split(exp,"\\*");
- return arrayInt[0]*arrayInt[1];
- }
- }
簡單的測試類：
- public class StrategyTest {
- public static void main(String[] args) {
- String exp = "2+8";
- ICalculator cal = new Plus();
- int result = cal.calculate(exp);
- System.out.println(result);
- }
- }
輸出：10
策略模式的決定權在使用者，系統本身提供不同演算法的實現，新增或者刪除演算法，對各種演算法做封裝。因此，策略模式多用在演算法決策系統中，外部使用者只需要決定用哪個演算法即可。
14、模板方法模式（Template Method）
解釋一下模板方法模式，就是指：一個抽象類中，有一個主方法，再定義1...n個方法，可以是抽象的，也可以是實際的方法，定義一個類，繼承該抽象類，重寫抽象方法，通過呼叫抽象類，實現對子類的呼叫，先看個關係圖：
就是在AbstractCalculator類中定義一個主方法calculate，calculate()呼叫spilt()等，Plus和Minus分別繼承AbstractCalculator類，通過對AbstractCalculator的呼叫實現對子類的呼叫，看下面的例子：
- public abstract class AbstractCalculator {
- /*主方法，實現對本類其它方法的呼叫*/
- public final int calculate(String exp,String opt){
- int array[] = split(exp,opt);
- return calculate(array[0],array[1]);
- }
- /*被子類重寫的方法*/
- abstract public int calculate(int num1,int num2);
- public int[] split(String exp,String opt){
- String array[] = exp.split(opt);
- int arrayInt[] = new int[2];
- arrayInt[0] = Integer.parseInt(array[0]);
- arrayInt[1] = Integer.parseInt(array[1]);
- return arrayInt;
- }
- }
- public class Plus extends AbstractCalculator {
- @Override
- public int calculate(int num1,int num2) {
- return num1 + num2;
- }
- }
測試類：
- public class StrategyTest {
- public static void main(String[] args) {
- String exp = "8+8";
- AbstractCalculator cal = new Plus();
- int result = cal.calculate(exp, "\\+");
- System.out.println(result);
- }
- }
我跟蹤下這個小程式的執行過程：首先將exp和"\\+"做引數，呼叫AbstractCalculator類裡的calculate(String,String)方法，在calculate(String,String)裡呼叫同類的split()，之後再呼叫calculate(int ,int)方法，從這個方法進入到子類中，執行完return num1 + num2後，將值返回到AbstractCalculator類，賦給result，列印出來。正好驗證了我們開頭的思路。
15、觀察者模式（Observer）
包括這個模式在內的接下來的四個模式，都是類和類之間的關係，不涉及到繼承，學的時候應該 記得歸納，記得本文最開始的那個圖。觀察者模式很好理解，類似於郵件訂閱和RSS訂閱，當我們瀏覽一些部落格或wiki時，經常會看到RSS圖示，就這的意思是，當你訂閱了該文章，如果後續有更新，會及時通知你。其實，簡單來講就一句話：當一個物件變化時，其它依賴該物件的物件都會收到通知，並且隨著變化！物件之間是一種一對多的關係。先來看看關係圖：
我解釋下這些類的作用：MySubject類就是我們的主物件，Observer1和Observer2是依賴於MySubject的物件，當MySubject變化時，Observer1和Observer2必然變化。AbstractSubject類中定義著需要監控的物件列表，可以對其進行修改：增加或刪除被監控物件，且當MySubject變化時，負責通知在列表記憶體在的物件。我們看實現程式碼：
一個Observer介面：
- public interface Observer {
- public void update();
- }
兩個實現類：
- public class Observer1 implements Observer {
- @Override
- public void update() {
- System.out.println("observer1 has received!");
- }
- }
- public class Observer2 implements Observer {
- @Override
- public void update() {
- System.out.println("observer2 has received!");
- }
- }
Subject介面及實現類：
- public interface Subject {
- /*增加觀察者*/
- public void add(Observer observer);
- /*刪除觀察者*/
- public void del(Observer observer);
- /*通知所有的觀察者*/
- public void notifyObservers();
- /*自身的操作*/
- public void operation();
- }
- public abstract class AbstractSubject implements Subject {
- private Vector<Observer> vector = new Vector<Observer>();
- @Override
- public void add(Observer observer) {
- vector.add(observer);
- }
- @Override
- public void del(Observer observer) {
- vector.remove(observer);
- }
- @Override
- public void notifyObservers() {
- Enumeration<Observer> enumo = vector.elements();
- while(enumo.hasMoreElements()){
- enumo.nextElement().update();
- }
- }
- }
- public class MySubject extends AbstractSubject {
- @Override
- public void operation() {
- System.out.println("update self!");
- notifyObservers();
- }
- }
測試類：
- public class ObserverTest {
- public static void main(String[] args) {
- Subject sub = new MySubject();
- sub.add(new Observer1());
- sub.add(new Observer2());
- sub.operation();
- }
- }
輸出：
update self!
observer1 has received!
observer2 has received!
這些東西，其實不難，只是有些抽象，不太容易整體理解，建議讀者：根據關係圖，新建專案，自己寫程式碼（或者參考我的程式碼）,按照總體思路走一遍，這樣才能體會它的思想，理解起來容易！
16、迭代子模式（Iterator）
顧名思義，迭代器模式就是順序訪問聚集中的物件，一般來說，集合中非常常見，如果對集合類比較熟悉的話，理解本模式會十分輕鬆。這句話包含兩層意思：一是需要遍歷的物件，即聚集物件，二是迭代器物件，用於對聚集物件進行遍歷訪問。我們看下關係圖：
這個思路和我們常用的一模一樣，MyCollection中定義了集合的一些操作，MyIterator中定義了一系列迭代操作，且持有Collection例項，我們來看看實現程式碼：
兩個介面：
- public interface Collection {
- public Iterator iterator();
- /*取得集合元素*/
- public Object get(int i);
- /*取得集合大小*/
- public int size();
- }
- public interface Iterator {
- //前移
- public Object previous();
- //後移
- public Object next();
- public boolean hasNext();
- //取得第一個元素
- public Object first();
- }
兩個實現：
- public class MyCollection implements Collection {
- public String string[] = {"A","B","C","D","E"};
- @Override
- public Iterator iterator() {
- return new MyIterator(this);
- }
- @Override
- public Object get(int i) {
- return string[i];
- }
- @Override
- public int size() {
- return string.length;
- }
- }
- public class MyIterator implements Iterator {
- private Collection collection;
- private int pos = -1;
- public MyIterator(Collection collection){
- this.collection = collection;
- }
- @Override
- public Object previous() {
- if(pos > 0){
- pos--;
- }
- return collection.get(pos);
- }
- @Override
- public Object next() {
- if(pos<collection.size()-1){
- pos++;
- }
- return collection.get(pos);
- }
- @Override
- public boolean hasNext() {
- if(pos<collection.size()-1){
- return true;
- }else{
- return false;
- }
- }
- @Override
- public Object first() {
- pos = 0;
- return collection.get(pos);
- }
- }
測試類：
- public class Test {
- public static void main(String[] args) {
- Collection collection = new MyCollection();
- Iterator it = collection.iterator();
- while(it.hasNext()){
- System.out.println(it.next());
- }
- }
- }
輸出：A B C D E
此處我們貌似模擬了一個集合類的過程，感覺是不是很爽？其實JDK中各個類也都是這些基本的東西，加一些設計模式，再加一些優化放到一起的，只要我們把這些東西學會了，掌握好了，我們也可以寫出自己的集合類，甚至框架！
17、責任鏈模式（Chain of Responsibility）
接下來我們將要談談責任鏈模式，有多個物件，每個物件持有對下一個物件的引用，這樣就會形成一條鏈，請求在這條鏈上傳遞，直到某一物件決定處理該請求。但是發出者並不清楚到底最終那個物件會處理該請求，所以，責任鏈模式可以實現，在隱瞞客戶端的情況下，對系統進行動態的調整。先看看關係圖：
Abstracthandler類提供了get和set方法，方便MyHandle類設定和修改引用物件，MyHandle類是核心，例項化後生成一系列相互持有的物件，構成一條鏈。
- public interface Handler {
- public void operator();
- }
- public abstract class AbstractHandler {
- private Handler handler;
- public Handler getHandler() {
- return handler;
- }
- public void setHandler(Handler handler) {
- this.handler = handler;
- }
- }
- public class MyHandler extends AbstractHandler implements Handler {
- private String name;
- public MyHandler(String name) {
- this.name = name;
- }
- @Override
- public void operator() {
- System.out.println(name+"deal!");
- if(getHandler()!=null){
- getHandler().operator();
- }
- }
- }
- public class Test {
- public static void main(String[] args) {
- MyHandler h1 = new MyHandler("h1");
- MyHandler h2 = new MyHandler("h2");
- MyHandler h3 = new MyHandler("h3");
- h1.setHandler(h2);
- h2.setHandler(h3);
- h1.operator();
- }
- }
輸出：
h1deal!
h2deal!
h3deal!
此處強調一點就是，連結上的請求可以是一條鏈，可以是一個樹，還可以是一個環，模式本身不約束這個，需要我們自己去實現，同時，在一個時刻，命令只允許由一個物件傳給另一個物件，而不允許傳給多個物件。
18、命令模式（Command）
命令模式很好理解，舉個例子，司令員下令讓士兵去幹件事情，從整個事情的角度來考慮，司令員的作用是，發出口令，口令經過傳遞，傳到了士兵耳朵裡，士兵去執行。這個過程好在，三者相互解耦，任何一方都不用去依賴其他人，只需要做好自己的事兒就行，司令員要的是結果，不會去關注到底士兵是怎麼實現的。我們看看關係圖：
Invoker是呼叫者（司令員），Receiver是被呼叫者（士兵），MyCommand是命令，實現了Command介面，持有接收物件，看實現程式碼：
- public interface Command {
- public void exe();
- }
- public class MyCommand implements Command {
- private Receiver receiver;
- public MyCommand(Receiver receiver) {
- this.receiver = receiver;
- }
- @Override
- public void exe() {
- receiver.action();
- }
- }
- public class Receiver {
- public void action(){
- System.out.println("command received!");
- }
- }
- public class Invoker {
- private Command command;
- public Invoker(Command command) {
- this.command = command;
- }
- public void action(){
- command.exe();
- }
- }
- public class Test {
- public static void main(String[] args) {
- Receiver receiver = new Receiver();
- Command cmd = new MyCommand(receiver);
- Invoker invoker = new Invoker(cmd);
- invoker.action();
- }
- }
輸出：command received!
這個很哈理解，命令模式的目的就是達到命令的發出者和執行者之間解耦，實現請求和執行分開，熟悉Struts的同學應該知道，Struts其實就是一種將請求和呈現分離的技術，其中必然涉及命令模式的思想！
其實每個設計模式都是很重要的一種思想，看上去很熟，其實是因為我們在學到的東西中都有涉及，儘管有時我們並不知道，其實在Java本身的設計之中處處都有體現，像AWT、JDBC、集合類、IO管道或者是Web框架，裡面設計模式無處不在。因為我們篇幅有限，很難講每一個設計模式都講的很詳細，不過我會盡我所能，儘量在有限的空間和篇幅內，把意思寫清楚了，更好讓大家明白。本章不出意外的話，應該是設計模式最後一講了，首先還是上一下上篇開頭的那個圖：
本章講講第三類和第四類。
19、備忘錄模式（Memento）
主要目的是儲存一個物件的某個狀態，以便在適當的時候恢復物件，個人覺得叫備份模式更形象些，通俗的講下：假設有原始類A，A中有各種屬性，A可以決定需要備份的屬性，備忘錄類B是用來儲存A的一些內部狀態，類C呢，就是一個用來儲存備忘錄的，且只能儲存，不能修改等操作。做個圖來分析一下：
Original類是原始類，裡面有需要儲存的屬性value及建立一個備忘錄類，用來儲存value值。Memento類是備忘錄類，Storage類是儲存備忘錄的類，持有Memento類的例項，該模式很好理解。直接看原始碼：
- public class Original {
- private String value;
- public String getValue() {
- return value;
- }
- public void setValue(String value) {
- this.value = value;
- }
- public Original(String value) {
- this.value = value;
- }
- public Memento createMemento(){
- return new Memento(value);
- }
- public void restoreMemento(Memento memento){
- this.value = memento.getValue();
- }
- }
- public class Memento {
- private String value;
- public Memento(String value) {
- this.value = value;
- }
- public String getValue() {
- return value;
- }
- public void setValue(String value) {
- this.value = value;
- }
- }
- public class Storage {
- private Memento memento;
- public Storage(Memento memento) {
- this.memento = memento;
- }
- public Memento getMemento() {
- return memento;
- }
- public void setMemento(Memento memento) {
- this.memento = memento;
- }
- }
測試類：
- public class Test {
- public static void main(String[] args) {
- // 建立原始類
- Original origi = new Original("egg");
- // 建立備忘錄
- Storage storage = new Storage(origi.createMemento());
- // 修改原始類的狀態
- System.out.println("初始化狀態為：" + origi.getValue());
- origi.setValue("niu");
- System.out.println("修改後的狀態為：" + origi.getValue());
- // 回覆原始類的狀態
- origi.restoreMemento(storage.getMemento());
- System.out.println("恢復後的狀態為：" + origi.getValue());
- }
- }
輸出：
初始化狀態為：egg
修改後的狀態為：niu
恢復後的狀態為：egg
簡單描述下：新建原始類時，value被初始化為egg，後經過修改，將value的值置為niu，最後倒數第二行進行恢復狀態，結果成功恢復了。其實我覺得這個模式叫“備份-恢復”模式最形象。
20、狀態模式（State）
核心思想就是：當物件的狀態改變時，同時改變其行為，很好理解！就拿QQ來說，有幾種狀態，線上、隱身、忙碌等，每個狀態對應不同的操作，而且你的好友也能看到你的狀態，所以，狀態模式就兩點：1、可以通過改變狀態來獲得不同的行為。2、你的好友能同時看到你的變化。看圖：
State類是個狀態類，Context類可以實現切換，我們來看看程式碼：
- package com.xtfggef.dp.state;
- /**
- * 狀態類的核心類
- * 2012-12-1
- * @author erqing
- *
- */
- public class State {
- private String value;
- public String getValue() {
- return value;
- }
- public void setValue(String value) {
- this.value = value;
- }
- public void method1(){
- System.out.println("execute the first opt!");
- }
- public void method2(){
- System.out.println("execute the second opt!");
- }
- }
- package com.xtfggef.dp.state;
- /**
- * 狀態模式的切換類 2012-12-1
- * @author erqing
- *
- */
- public class Context {
- private State state;
- public Context(State state) {
- this.state = state;
- }
- public State getState() {
- return state;
- }
- public void setState(State state) {
- this.state = state;
- }
- public void method() {
- if (state.getValue().equals("state1")) {
- state.method1();
- } else if (state.getValue().equals("state2")) {
- state.method2();
- }
- }
- }
- public class Test {
- public static void main(String[] args) {
- State state = new State();
- Context context = new Context(state);
- //設定第一種狀態
- state.setValue("state1");
- context.method();
- //設定第二種狀態
- state.setValue("state2");
- context.method();
- }
- }
execute the first opt!
execute the second opt!
根據這個特性，狀態模式在日常開發中用的挺多的，尤其是做網站的時候，我們有時希望根據物件的某一屬性，區別開他們的一些功能，比如說簡單的許可權控制等。
21、訪問者模式（Visitor）
訪問者模式把資料結構和作用於結構上的操作解耦合，使得操作集合可相對自由地演化。訪問者模式適用於資料結構相對穩定演算法又易變化的系統。因為訪問者模式使得演算法操作增加變得容易。若系統資料結構物件易於變化，經常有新的資料物件增加進來，則不適合使用訪問者模式。訪問者模式的優點是增加操作很容易，因為增加操作意味著增加新的訪問者。訪問者模式將有關行為集中到一個訪問者物件中，其改變不影響系統資料結構。其缺點就是增加新的資料結構很困難。—— From 百科
簡單來說，訪問者模式就是一種分離物件資料結構與行為的方法，通過這種分離，可達到為一個被訪問者動態新增新的操作而無需做其它的修改的效果。簡單關係圖：
來看看原碼：一個Visitor類，存放要訪問的物件，
- public interface Visitor {
- public void visit(Subject sub);
- }
- public class MyVisitor implements Visitor {
- @Override
- public void visit(Subject sub) {
- System.out.println("visit the subject："+sub.getSubject());
- }
- }
- public interface Subject {
- public void accept(Visitor visitor);
- public String getSubject();
- }
- public class MySubject implements Subject {
- @Override
- public void accept(Visitor visitor) {
- visitor.visit(this);
- }
- @Override
- public String getSubject() {
- return "love";
- }
- }
- public class Test {
- public static void main(String[] args) {
- Visitor visitor = new MyVisitor();
- Subject sub = new MySubject();
- sub.accept(visitor);
- }
- }
該模式適用場景：如果我們想為一個現有的類增加新功能，不得不考慮幾個事情：1、新功能會不會與現有功能出現相容性問題？2、以後會不會再需要新增？3、如果類不允許修改程式碼怎麼辦？面對這些問題，最好的解決方法就是使用訪問者模式，訪問者模式適用於資料結構相對穩定的系統，把資料結構和演算法解耦，
22、中介者模式（Mediator）
中介者模式也是用來降低類類之間的耦合的，因為如果類類之間有依賴關係的話，不利於功能的擴充和維護，因為只要修改一個物件，其它關聯的物件都得進行修改。如果使用中介者模式，只需關心和Mediator類的關係，具體類類之間的關係及排程交給Mediator就行，這有點像spring容器的作用。先看看圖：
User類統一介面，User1和User2分別是不同的物件，二者之間有關聯，如果不採用中介者模式，則需要二者相互持有引用，這樣二者的耦合度很高，為了解耦，引入了Mediator類，提供統一介面，MyMediator為其實現類，裡面持有User1和User2的例項，用來實現對User1和User2的控制。這樣User1和User2兩個物件相互獨立，他們只需要保持好和Mediator之間的關係就行，剩下的全由MyMediator類來維護！基本實現：
- public interface Mediator {
- public void createMediator();
- public void workAll();
- }
- public class MyMediator implements Mediator {
- private User user1;
- private User user2;
- public User getUser1() {
- return user1;
- }
- public User getUser2() {
- return user2;
- }
- @Override
- public void createMediator() {
- user1 = new User1(this);
- user2 = new User2(this);
- }
- @Override
- public void workAll() {
- user1.work();
- user2.work();
- }
- }
- public abstract class User {
- private Mediator mediator;
- public Mediator getMediator(){
- return mediator;
- }
- public User(Mediator mediator) {
- this.mediator = mediator;
- }
- public abstract void work();
- }
- public class User1 extends User {
- public User1(Mediator mediator){
- super(mediator);
- }
- @Override
- public void work() {
- System.out.println("user1 exe!");
- }
- }
- public class User2 extends User {
- public User2(Mediator mediator){
- super(mediator);
- }
- @Override
- public void work() {
- System.out.println("user2 exe!");
- }
- }
- public class Test {
- public static void main(String[] args) {
- Mediator mediator = new MyMediator();
- mediator.createMediator();
- mediator.workAll();
- }
- }
user1 exe!
user2 exe!
23、直譯器模式（Interpreter）
直譯器模式是我們暫時的最後一講，一般主要應用在OOP開發中的編譯器的開發中，所以適用面比較窄。
Context類是一個上下文環境類，Plus和Minus分別是用來計算的實現，程式碼如下：
- public interface Expression {
- public int interpret(Context context);
- }
- public class Plus implements Expression {
- @Override
- public int interpret(Context context) {
- return context.getNum1()+context.getNum2();
- }
- }
- public class Minus implements Expression {
- @Override
- public int interpret(Context context) {
- return context.getNum1()-context.getNum2();
- }
- }
- public class Context {
- private int num1;
- private int num2;
- public Context(int num1, int num2) {
- this.num1 = num1;
- this.num2 = num2;
- }
- public int getNum1() {
- return num1;
- }
- public void setNum1(int num1) {
- this.num1 = num1;
- }
- public int getNum2() {
- return num2;
- }
- public void setNum2(int num2) {
- this.num2 = num2;
- }
- }
- public class Test {
- public static void main(String[] args) {
- // 計算9+2-8的值
- int result = new Minus().interpret((new Context(new Plus()
- .interpret(new Context(9, 2)), 8)));
- System.out.println(result);
- }
- }
基本就這樣，直譯器模式用來做各種各樣的直譯器，如正規表示式等的直譯器等等！
設計模式基本就這麼大概講完了，總體感覺有點簡略，的確，這麼點兒篇幅，不足以對整個23種設計模式做全面的闡述，此處讀者可將它作為一個理論基礎去學習，通過這三篇博文，先基本有個概念，雖然我講的有些簡單，但基本都能說明問題及他們的特點，如果對哪一個感興趣，可以繼續深入研究！同時我也會不斷更新，儘量補全遺
相關文章
- Java開發中的23種設計模式詳解(轉)Java設計模式
- Java開發中的23種設計模式詳解之一：5種建立型模式Java設計模式
- Java開發中的23種設計模式詳解之二：7種結構型模式Java設計模式
- Java開發中的23種設計模式Java設計模式
- java 23種設計模式 /Java設計模式
- 23種java設計模式Java設計模式
- 圖文詳解23種設計模式設計模式
- 詳細講解23種設計模式設計模式
- java中23種設計模式--原型模式(Portotype)Java設計模式原型
- 設計模式之三種工廠模式設計模式
- 行為型設計模式 - 狀態模式詳解設計模式
- 行為型設計模式 - 觀察者模式詳解設計模式
- 重溫23種設計模式（11）：原型模式設計模式原型
- 23種設計模式設計模式
- 四種設計模式詳解設計模式
- 行為型設計模式 - 備忘錄模式詳解設計模式
- 行為型設計模式 - 責任鏈模式詳解設計模式
- java23種設計模式—— 二、單例模式Java設計模式單例
- java23種設計模式——三、工廠模式Java設計模式
- java23種設計模式——四、原型模式Java設計模式原型
- java23種設計模式——五、建造者模式Java設計模式
- java23種設計模式——八、組合模式Java設計模式
- 詳解 Java 中的三種代理模式Java模式
- iOS開發中的21種設計模式iOS設計模式
- java23種設計模式-門面模式（外觀模式）Java設計模式
- 23種設計模式(四)-代理模式設計模式
- 23種設計模式（7）-代理模式設計模式
- 23種設計模式之策略模式設計模式
- 23種設計模式之命令模式設計模式
- 23種設計模式(二)---策略設計模式設計模式
- 23種設計模式(八)-原型設計模式設計模式原型
- 追MM與Java的23種設計模式Java設計模式
- java 23種設計模式 深入理解Java設計模式
- (Java)設計模式：行為型Java設計模式
- Java23種設計模式【22】----》觀察者模式（Observer）Java設計模式Server
- java23種設計模式——六、介面卡模式Java設計模式
- java23種設計模式之抽象工廠模式Java設計模式抽象
- 【圖解設計模式系列】23句話總結23種設計模式圖解設計模式