前言

此篇博文內容續接的是 UML建模語言、設計原則、建立型設計模式的內容，有興趣的可以點前面的連結去看一下

3.2、行為型

這類設計模式是專門用於：物件間的高效溝通和職責委派

* 3.2.1、責任鏈模式

定義：責任鏈模式又名職責鏈模式，指的是：對某個請求的所有處理構成一條鏈，如果鏈上的某一處理者可以處理，則處理後返回。如果不能處理則將請求傳遞給鏈上的下一個處理者

廢話文學：所謂責任鏈模式就是為了避免請求傳送者與多個請求處理者耦合在一起，於是將所有請求的處理者通過前一物件記住其下一個物件的參照而連成一條鏈；當有請求發生時，可將請求沿著這條鏈傳遞，直到有物件處理它為止

場景理解：開發中的捕獲異常，只有遇到對應的某一個或某一類異常時，才會有對應的處理機制；還有Servlet程式設計中的Filter過濾器；以及SpringMVC執行原理（請求經過DispatcherServlet，然後經其轉到HandletMapping，然後通過HandlerExcuttionChain這條執行鏈將結果返回給DispatcherServlet.....，）

圖示理解：使用的是Servlet的Filter舉例

生活中的例子：跳槽離職，要找好多人審批、以及擊鼓傳花.....
使用場景：在處理訊息的時候要過濾很多道時就可以使用責任鏈模式

責任鏈模式的角色

抽象處理者：一個請求介面，裡面包含抽象的處理請求的方法和後繼連結
具體處理者：抽象處理者的子類，實現了處理請求方法，判斷請求是否能夠處理，能則處理返回結果，否則將請求傳給它的後繼者
使用者端：建立處理鏈，並向鏈頭的具體處理者物件提交請求，它不關心處理細節和請求的傳遞過程

責任鏈模式的類圖

3.2.1.1、簡單邏輯

1、抽象處理者

package com.zixieqing.handler;

/**
 * <p>@description  : 該類功能  抽象處理者：做使用者名稱判斷
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public abstract class AbstractHakimHandler {

    private AbstractHakimHandler next;

    public AbstractHakimHandler getNext() {
        return next;
    }

    public void setNext(AbstractHakimHandler next) {
        this.next = next;
    }

    public abstract String hakim(String name);
}

2、具體處理者

  package com.zixieqing.handler;

  import com.zixieqing.UsernameEnum;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;

  /**
   * <p>@description  : 該類功能  第一個處理者
   * </p>
   * <p>@package      : com.zixieqing</p>
   * <p>@author       : ZiXieqing</p>
   * <p>@version      : V1.0.0</p>
   */

  public class OneHakimHandler extends AbstractHakimHandler{

      private Logger logger = LoggerFactory.getLogger(OneHakimHandler.class);

      @Override
      public String hakim(String name) {
          logger.info("進入OneHakimHandler處理器");

          // 如果當前處理者能處理該請求，則進行處理，返回結果
          if (UsernameEnum.ZIXIEQING.toString().equals(name.trim().toUpperCase())) {
              return "歡迎：" + name + " 進入系統";
          }

          // 如果當前處理者不能處理改請求，則丟給後繼者
          if (null != getNext())
              return getNext().hakim(name);

          return "沒有處理者能夠處理該請求";
      }
  }

  package com.zixieqing.handler;

  import com.zixieqing.UsernameEnum;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;

  /**
   * <p>@description  : 該類功能  第二個處理者
   * </p>
   * <p>@package      : com.zixieqing.handler</p>
   * <p>@author       : ZiXieqing</p>
   * <p>@version      : V1.0.0</p>
   */

  public class TwoHakimHandler extends AbstractHakimHandler{

      private Logger logger = LoggerFactory.getLogger(OneHakimHandler.class);

      @Override
      public String hakim(String name) {
          logger.info("進入TwoHakimHandler處理器");

          if (UsernameEnum.ZIMINGXUAN.toString().equals(name.trim().toUpperCase())) {
              logger.info("正在進行資料查詢..........");
              logger.info("查詢到使用者：{}", name);
              return "歡迎：" + name + " 進入系統";
          }

          if (null != getNext())
              return getNext().hakim(name);

          return "沒有處理者能夠處理該請求";
      }
  }

上述涉及到的列舉類

  package com.zixieqing;

  /**
   * <p>@description  : 該類功能  使用者名稱集合
   * </p>
   * <p>@package      : com.zixieqing</p>
   * <p>@author       : ZiXieqing</p>
   * <p>@version      : V1.0.0</p>
   */

  public enum UsernameEnum {

      /**
       * 紫邪情
       */
      ZIXIEQING,

      /**
       * 紫明軒
       */
      ZIMINGXUAN,

      ;

  }

3、使用者端

package com.zixieqing;

import com.zixieqing.handler.OneHakimHandler;
import com.zixieqing.handler.TwoHakimHandler;

/**
 * <p>@description  : 該類功能  使用者端:這部分的程式碼可以封裝起來，然後提供一個公共方法給外部呼叫即可
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class APITest{

    public static void main(String[] args) {

        // 建立處理鏈 並 將請求丟給鏈頭的處理者
        OneHakimHandler handler1 = new OneHakimHandler();
        handler1.setNext(new TwoHakimHandler());

        System.out.println(handler1.hakim("LISI"));

        System.out.println("============華麗的分隔符=============");

        System.out.println(handler1.hakim("ZIXIEQING"));

        System.out.println("============華麗的分隔符=============");

        System.out.println(handler1.hakim("zimingxuan"));
    }
}

責任鏈模式的不足

不能保證每個請求一定能被處理，如：上面的「LISI"，原因：因為請求沒有明確的接收者，所以一個請求可能一直傳到處理鏈的末端都還未被處理
責任鏈是否合理需要靠使用者端來進行建立，所以增加了使用者端的複雜性，可能出現使用者端中責任鏈的錯誤設定而導致系統出錯
如果使用者端中的責任鏈過長，那麼就需要很多個處理物件的參與，所以系統效能會受到影響

* 3.2.2、命令模式

定義：指的是請求以命令的形式包裹在物件中，並傳給呼叫物件。呼叫物件尋找可以處理該命令的合適的物件，並把該命令傳給相應的物件，該物件執行命令

命令模式是將操作請求（行為請求者）和邏輯實現（行為實現者）進行了分離，從而降低耦合、方便擴充套件

適用場景： 只要認為是命令的地方都可以使用，如：CMD、GUI介面中的按鈕............

命令模式類圖

場景理解：
- 電視機換臺：1、想要換臺（呼叫者：發起請求）；2、按下遙控器的換臺按鈕（將請求包裝成了命令物件）；3、電視機進行換臺（接收者：執行請求相應的操作）
- 去飯店吃飯：1、你要吃飯（呼叫者：你要選單上的某菜，整個選單就是所有可以呼叫的命令）；2、跟服務員講你要選單上的什麼菜（命令物件：服務員在本子上記下菜名，即：將請求轉成了命令物件）；3、服務員將寫有菜名的紙交給廚師（接收者：廚師通過命令物件接收到呼叫者的請求，開始對應的操作：炒菜）

3.2.2.1、簡單邏輯

使用上面去飯店吃飯為例，對這個場景進行拆解，可以得到如下的邏輯圖

服務員：呼叫者
選單：命令
廚師：接收者
邏輯順序是：呼叫者（invoker）——> 命令（command) ——> 接收者（receiver）；而我寫程式碼的習慣順序是逆向的

1、先決條件

菜組成

package com.zixieqing;

import lombok.Data;
import lombok.ToString;
import lombok.experimental.Accessors;

import java.util.List;

/**
 * <p>@description  : 該類功能  菜
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

@Data
@ToString
@Accessors(chain = true)
public class Food {

    /**
     * 菜名
     */
    private String name;

    /**
     * 油：菜油、豬油、地溝油(^_^)......
     */
    private String oil;

    /**
     * 辣椒型別：有線辣椒、小米椒、青椒、朝天椒..........
     */
    private String chili;

    /**
     * 配料：食鹽、味精、八角、糖、醬油、耗油、醋、料酒、姜、蔥、蒜.........
     */
    private List<String> excipients;

    /**
     * 容器：碗、鍋、盤子
     */
    private String container;
}

選單列舉類

package com.zixieqing;

/**
 * <p>@description  : 該類功能  選單列舉類：就是去點菜時需要看有哪些菜的選單
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public enum MenuEnum {

    /**
     * 魚香肉絲
     */
    YU_XIANG_ROU_SI("魚香肉絲", "18"),

    /**
     * 鴛鴦鍋
     */
    YUAN_YANG_GUO("鴛鴦鍋", "50"),

    ;

    private String foodName;

    private String price;

    MenuEnum(String foodName, String price) {
        this.foodName = foodName;
        this.price = price;
    }

    public String getFoodName() {
        return foodName;
    }

    public void setFoodName(String foodName) {
        this.foodName = foodName;
    }

    public String getPrice() {
        return price;
    }

    public void setPrice(String price) {
        this.price = price;
    }
}

2、接收者：廚師

package com.zixieqing.command;

import com.zixieqing.Food;

import java.util.List;

/**
 * <p>@description  : 該類功能  廚師
 * </p>
 * <p>@package      : com.zixieqing.command</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface IChef {

    Food cook(List<String> foodList);
}

張師：專做火鍋系列

package com.zixieqing.command.impl;

import com.zixieqing.Food;
import com.zixieqing.MenuEnum;
import com.zixieqing.command.IChef;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * <p>@description  : 該類功能  張師：假如他是專門做火鍋系列的
 * </p>
 * <p>@package      : com.zixieqing.command.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ZhangChefImpl implements IChef {

    private Logger logger = LoggerFactory.getLogger(ZhangChefImpl.class);

    @Override
    public Food cook(List<String> foodList) {
        for (String name : foodList) {
            if (MenuEnum.YUAN_YANG_GUO.getFoodName().equals(name)) {
                logger.info("張師正在準備做：{}", name);

                List<String> excipients = new ArrayList<>();
                excipients.add("食鹽半勺");
                excipients.add("味精少量");
                excipients.add("八角微量");
                excipients.add("糖少許");
                excipients.add("醬油半勺");
                excipients.add("耗油微量");
                excipients.add("蔥薑蒜適量");

                Food food = new Food();
                food.setName(name)
                        .setOil("菜油")
                        .setChili("朝天椒")
                        .setExcipients(excipients)
                        .setContainer("鴛鴦鍋");

                logger.info("張師做好了：{}，成品為：{}", name, food);

                return food;
            }
        }

        return null;
    }
}

李師：專做炒菜系列

package com.zixieqing.command.impl;

import com.zixieqing.Food;
import com.zixieqing.MenuEnum;
import com.zixieqing.command.IChef;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * <p>@description  : 該類功能  李師：假如他是專門做炒菜系列的
 * </p>
 * <p>@package      : com.zixieqing.command.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class LiChefImpl implements IChef {

    private Logger logger = LoggerFactory.getLogger(LiChefImpl.class);

    @Override
    public Food cook(List<String> foodList) {
        for (String name : foodList) {
            if (MenuEnum.YU_XIANG_ROU_SI.getFoodName().equals(name)) {
                logger.info("李師正在準備做：{}", name);

                List<String> excipients = new ArrayList<>();
                excipients.add("食鹽少量");
                excipients.add("味精少許");
                excipients.add("蔥蒜少許");

                Food food = new Food();
                food.setName(name)
                        .setOil("豬油")
                        .setChili("青椒")
                        .setExcipients(excipients)
                        .setContainer("盤子");

                logger.info("李師做好了：{}，成品為：{}", name, food);

                return food;
            }
        }
        return null;
    }
}

3、命令：選單

package com.zixieqing.command;

import java.util.List;

/**
 * <p>@description  : 該類功能  選單：就是服務員在紙上寫的那些菜名，即：命令物件
 * </p>
 * <p>@package      : com.zixieqing.command</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface IMenu {

    void make(List<String> foodList);
}

火鍋型別選單

package com.zixieqing.command.impl;

import com.zixieqing.command.IChef;
import com.zixieqing.command.IMenu;

import java.util.List;

/**
 * <p>@description  : 該類功能  火鍋型別的選單
 * </p>
 * <p>@package      : com.zixieqing.command.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class HuoGuoMenuImpl implements IMenu {

    private IChef chef;

    public HuoGuoMenuImpl(IChef chef) {
        this.chef = chef;
    }

    @Override
    public void make(List<String> foodList) {
        chef.cook(foodList);
    }
}

炒菜型別選單

package com.zixieqing.command.impl;

import com.zixieqing.command.IChef;
import com.zixieqing.command.IMenu;

import java.util.List;

/**
 * <p>@description  : 該類功能  炒菜型別的選單
 * </p>
 * <p>@package      : com.zixieqing.command.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ChaoCaiMenuImpl implements IMenu {

    private IChef chef;

    public ChaoCaiMenuImpl(IChef chef) {
        this.chef = chef;
    }

    @Override
    public void make(List<String> foodList) {
        chef.cook(foodList);
    }
}

4、呼叫者：服務員

package com.zixieqing.command;

import com.zixieqing.MenuEnum;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * <p>@description  : 該類功能  服務員
 * </p>
 * <p>@package      : com.zixieqing.command</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Waiter {

    private Logger logger = LoggerFactory.getLogger(Waiter.class);

    /**
     * 服務員本子上記的菜名
     */
    private List<String> foodList = new ArrayList<>();
    /**
     * 本店選單
     */
    private MenuEnum[] values = MenuEnum.values();

    private IMenu menu;

    public Waiter(IMenu menu) {
        this.menu = menu;
    }

    /**
     * <p>@description  : 該方法功能 點單
     * </p>
     * <p>@methodName   : order</p>
     * <p>@author: ZiXieqing</p>
     * <p>@version: V1.0.0</p>
     * @param foodName  菜名
     */
    public void order(String foodName) {

        for (MenuEnum value : values) {
            // 判斷客人所說的菜名是否在本店的選單中
            if (foodName.trim().equals(value.getFoodName()))
                this.foodList.add(foodName);
        }
    }

    /**
     * <p>@description  : 該方法功能 下單
     * </p>
     * <p>@methodName   : placeOrder</p>
     * <p>@author: ZiXieqing</p>
     * <p>@version: V1.0.0</p>
     *
     */
    public void placeOrder() {
        menu.make(foodList);

        foodList.clear();
    }
}

5、測試



package com.zixieqing;

import com.zixieqing.command.Waiter;
import com.zixieqing.command.impl.ChaoCaiMenuImpl;
import com.zixieqing.command.impl.HuoGuoMenuImpl;
import com.zixieqing.command.impl.LiChefImpl;
import com.zixieqing.command.impl.ZhangChefImpl;

/**
 * <p>@description  : 該類功能  測試
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class APITest {

    public static void main(String[] args) {

        Waiter waiter = new Waiter(new HuoGuoMenuImpl(new ZhangChefImpl()));

        // 點單
        waiter.order("鴛鴦鍋");

        // 下單
        waiter.placeOrder();

        System.out.println("==========華麗的分隔符==========");

        Waiter newWaiter = new Waiter(new ChaoCaiMenuImpl(new LiChefImpl()));

        // 點單
        newWaiter.order("魚香肉絲");

        // 下單
        newWaiter.placeOrder();
    }
}

結果

11:43:54.317 [main] INFO  c.z.command.impl.ZhangChefImpl - 張師正在準備做：鴛鴦鍋
11:43:54.320 [main] INFO  c.z.command.impl.ZhangChefImpl - 張師做好了：鴛鴦鍋，成品為：Food(name=鴛鴦鍋, oil=菜油, chili=朝天椒, excipients=[食鹽半勺, 味精少量, 八角微量, 糖少許, 醬油半勺, 耗油微量, 蔥薑蒜適量], container=鴛鴦鍋)
==========華麗的分隔符==========
11:43:54.320 [main] INFO  c.zixieqing.command.impl.LiChefImpl - 李師正在準備做：魚香肉絲
11:43:54.320 [main] INFO  c.zixieqing.command.impl.LiChefImpl - 李師做好了：魚香肉絲，成品為：Food(name=魚香肉絲, oil=豬油, chili=青椒, excipients=[食鹽少量, 味精少許, 蔥蒜少許], container=盤子)

命令模式的優點：

將發出命令的責任和執行命令的責任分隔開（請求者 / 呼叫者和執行者 / 接收者沒有必然聯絡），請求的一方不必知道接收請求的一方的介面，更不必知道請求如何被接收、操作是否被執行、何時被執行，以及是怎麼被執行的，所以降低了請求發出者和請求執行者之間的耦合，當然也方便擴充套件（Command命令採用的是介面+實現類或是抽象類+實現類）

命令模式的缺點：

和簡單工廠模式差不多，要是命令Command很多的話，那麼實現類就會變多，造成類臃腫，比較繁瑣

* 3.2.3、迭代器模式

定義：迭代、迭代，就是遍歷唄，所以指的就是：提供一種順序存取集合容器 / 複雜物件中各個元素的方法，又無須暴露集合容器的內部表示

本質：就是將一個集合容器的遍歷方法抽取出來，然後單獨弄到一個迭代器物件中，從而：做到讓我們以相同的方式，可以遍歷不同資料結構的集合容器（這也是這個模式的應用場景）

典型例子：List、Set系列的集合，他們都繼承了Iterable介面，都有Iterator型別的iterator()方法，而hasNext()和next()方法就在Iterator介面中

迭代器模式的角色

抽象迭代器（Iterator）：負責定義存取和遍歷元素的介面，通常包含 hasNext()、next() 等方法
具體迭代器（Concretelterator）：實現抽象迭代器介面中所定義的方法，完成對聚合物件的遍歷，記錄遍歷的當前位置
抽象容器（Aggregate）：負責定義建立具體迭代器的介面、以及所謂的對集合容器 / 複雜物件的增刪改這些方法
具體容器（ConcreteAggregate）：抽象容器的子類，負責建立具體迭代器 / 返回迭代器範例

迭代器模式的邏輯

從上面那個list的構成其實也知道了

3.2.3.1、簡單邏輯

注：下面這個邏輯沒多大意思，就意思意思而已，只是為了理解邏輯，因為搞的就是套娃

1、抽象迭代器

package com.zixieqing.o1simple;

/**
 * <p>@description  : 該類功能  抽象迭代器
 * </p>
 * <p>@package      : com.zixieqing.o1simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface Iterator<E> {

    boolean hasNext();

    E next();
}

2、具體迭代器

package com.zixieqing.o1simple.impl;

import com.zixieqing.o1simple.Iterator;

import java.util.List;

/**
 * <p>@description  : 該類功能  具體迭代器
 * </p>
 * <p>@package      : com.zixieqing.o1simple.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class IteratorImpl<E> implements Iterator<E> {

    /**
     * 下一個元素的索引
     */
    private int cursor;

    /**
     * 最後一個元素的索引，如果沒有就返回-1
     */
    private int lastRet = -1;

    private List<E> list;

    public IteratorImpl(List<E> list) {
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        return this.cursor < list.size();
    }

    @Override
    public E next() {
        return this.list.get(cursor++);
    }
}

3、抽象容器

package com.zixieqing.o1simple;

/**
 * <p>@description  : 該類功能  抽象容器
 * </p>
 * <p>@package      : com.zixieqing.o1simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface ICollection<E> {

    Iterator<E> iterator();

    boolean add(E element);
}

4、具體容器

package com.zixieqing.o1simple;

import com.zixieqing.o1simple.impl.IteratorImpl;

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

/**
 * <p>@description  : 該類功能  具體容器
 * </p>
 * <p>@package      : com.zixieqing.o1simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class NewList<E> implements ICollection<E>{

    private List<E> list = new ArrayList<>();

    @Override
    public Iterator<E> iterator() {
        return new IteratorImpl<>(list);
    }

    @Override
    public boolean add(E element) {
        return list.add(element);
    }
}

5、測試

package com.zixieqing;

import com.zixieqing.o1simple.Iterator;
import com.zixieqing.o1simple.NewList;

/**
 * <p>@description  : 該類功能  測試
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ApiTest {

    public static void main(String[] args) {
        NewList<Integer> newList = new NewList<>();
        newList.add(1);
        newList.add(2);
        newList.add(3);
        newList.add(4);
        newList.add(5);

        Iterator<Integer> iterator = newList.iterator();
        while (iterator.hasNext())
            System.out.println(iterator.next());
    }
}

迭代器模式的優點：

在不需要暴露聚合物件的內部結構的情況下，可以讓我們以相同的方式遍歷不同資料結構（連結串列、陣列、樹.......）的聚合物件 / 集合容器的各個元素

迭代器模式的缺點：

它的缺點和工廠方法模式的缺點是類似的，因為迭代器模式是將容器儲存資料和遍歷資料進行了分離，所以就會造成：新增聚合物件就可能需要新增迭代器類（主要為具體迭代器）

使用場景：

想要遍歷不同的聚合結構，這時提供一個統一的介面（迭代器）
想要為聚合物件提供多種遍歷方式

* 3.2.4、中介者模式

定義：我拿你的錢，辦你的事兒；所謂的中介者就是一個和事佬

處理的問題：物件之間存在的依賴關係（多個類相互耦合，形成了網狀結構），即：一個類的方法中用到了另一個的物件（可以是把A類物件當做B類方法的引數；可以是B類方法中new了A類的範例；也可以是B類中的屬性參照了A類物件[但：沒有new，即：聚合]，然後在B類方法中new出範例。如果有很多個類之間存在依賴關係，那麼就會造成只要動一個類，則很多類都要進行整改，這就是所謂的牽一髮而動全身，典型例子就是如下的關係：

中介者模式的角色

抽象中介者（Mediator）：定義統一的介面，用於各同事角色之間的通訊
具體中介者（ConcreteMediator）：通過協調各同事物件實現共同作業行為，因此它必須依賴於各個同事角色
同事類（Colleague）：每一個同事角色都知道中介者角色，而且與其他的同事角色通訊的時候，一定要通過中介者角色共同作業。每個同事類的行為分為兩種：
- 一種是同事本身的行為，比如改變物件本身的狀態，處理自己的行為等，這種行為叫做自發行為，與其他的同事類或中介者沒有任何的依賴
- 第二種是必須依賴中介者才能完成的行為，叫做依賴方法
- 當然：根據需要也可以把同事類進行抽取，進而變成：抽象同事類+具體同事類

3.2.4.1、簡單邏輯

情景：男女分手+中間調和者，類圖邏輯如下：

1、抽象中介者 / 抽象協調者

package com.zixieqing.o1simple;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>@description  : 該類功能  抽象協調者
 * </p>
 * <p>@package      : com.zixieqing.o1simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public abstract class Coordinator {

    private Logger logger = LoggerFactory.getLogger(Coordinator.class);

    protected Man man;

    protected Woman woman;

    public Coordinator() {
        man = new Man(this);
        woman = new Woman(this);
    }

    /**
     * 中介者 / 協調者的核心方法：處理同事角色關係
     *
     * @param type  事件型別 1、傳話；2、退還物品
     * @param thing 發生對應型別時要做的事
     */
    public abstract void handler(int type, String thing);

    /**
     * 傳話
     *
     * @param context 傳話內容
     */
    public abstract void message(String context);

    /**
     * 退還物品
     *
     * @param thing 要退還的東西
     */
    public abstract void handover(String thing);
}

2、具體中介者

package com.zixieqing.o1simple;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>@description  : 該類功能  具體協調者
 * </p>
 * <p>@package      : com.zixieqing.o1simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ConsreteConnrdinator extends Coordinator {

    private Logger logger = LoggerFactory.getLogger(ConsreteConnrdinator.class);

    /**
     * 代表吵架
     */
    private static final int QUARREL = 1;

    /**
     * 代表退還物品
     */
    private static final int HANDOVER = 2;

    /**
     * MAG_FLAG 訊息標識 1、給女傳話；2、給男傳話
     * HANDOVER_FLAG 退還物品標識 1、給女退還物品；2、給男退還物品
     */
    public static int MSG_FLAG = 1, HANDOVER_FLAG = 1;

    /**
     * 中介者 / 協調者的核心方法：處理同事角色關係
     * @param type 事件型別 1、傳話；2、退還物品
     * @param thing 發生對應型別時要做的事
     */
    @Override
    public void handler(int type, String thing) {
        switch (type) {
            case QUARREL:
                this.message(thing);
                break;
            case HANDOVER:
                this.handover(thing);
                break;
            default:
                logger.info("貧道愛莫能助，只能擺爛..........");
        }
    }

    /**
     * 傳話
     * @param context 傳話內容
     */
    @Override
    public void message(String context) {
        if (1==MSG_FLAG)
            super.woman.talkToFriend(context);

        if (2==MSG_FLAG)
            super.man.love(context);
    }

    /**
     * 退還物品
     *
     * @param thing 要退還的東西
     */
    @Override
    public void handover(String thing) {
        if (1==HANDOVER_FLAG)
            super.woman.talkToFriend(thing);

        if (2==HANDOVER_FLAG)
            super.man.love(thing);
    }
}

3、同事類：男人

package com.zixieqing.o1simple;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Scanner;

/**
 * <p>@description  : 該類功能  男人：同事類A
 * </p>
 * <p>@package      : com.zixieqing.o1simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Man {

    private Logger logger = LoggerFactory.getLogger(Man.class);

    /**
     * 聚合協調者
     */
    private Coordinator coordinator;

    /**
     * 姓名
     */
    private String name;

    /**
     * 年齡
     */
    private int age;

    /**
     * 敏感詞
     */
    private String filter = "不聽，不聽，分手";

    public Man(Coordinator coordinator) {
        this.coordinator = coordinator;
    }

    /**
     * 吃
     * @param foodName 食物名
     */
    public void eat(String foodName) {
        logger.info("這個男人今天吃了：{}", foodName);
    }

    /**
     * 喝
     * @param drinkName 飲料名
     */
    public void drink(String drinkName) {
        logger.info("這個男人剛剛喝了：{}", drinkName);
    }

    /**
     * 做飯
     * @param foodName 菜名
     */
    public void cook(String foodName) {
        logger.info("這個男人正在做：{}", foodName);
    }

    /**
     * 談戀愛
     * @param thing 做的是戀愛中的什麼事
     */
    public void love(String thing) {
        logger.info("女：{}", thing);
        if (thing.trim().equals(filter)) {
            ConsreteConnrdinator.MSG_FLAG = 1;
            coordinator.handler(1,"你這娘們兒簡直不可理喻，分就分");
        }

        ConsreteConnrdinator.MSG_FLAG = 1;
        Scanner input = new Scanner(System.in);
        coordinator.handler(1,input.next());
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

4、同事類：女人

package com.zixieqing.o1simple;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Scanner;

/**
 * <p>@description  : 該類功能  女人：同事類B
 * </p>
 * <p>@package      : com.zixieqing.o1simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Woman {

    private Logger logger = LoggerFactory.getLogger(Woman.class);

    private Coordinator coordinator;

    private String name;

    private int age;

    /**
     * 火藥桶
     */
    private String gunpowder = "你這娘們兒簡直不可理喻，分就分";

    public Woman(Coordinator coordinator) {
        this.coordinator = coordinator;
    }

    /**
     * 逛街購物
     */
    public void shopping() {
        logger.info("這個仙女今天去哪裡逛街，又買了xxxxxxxxxxx");
    }

    /**
     * 耍朋友
     */
    public void talkToFriend(String context) {
        logger.info("男：{}",context);
        // 如果觸碰火藥桶，那就退還物品
        if (context.trim().equals(gunpowder)) {
            logger.info("分就分，把他的破東西拿回去..........");
            ConsreteConnrdinator.HANDOVER_FLAG = 2;
            ConsreteConnrdinator.MSG_FLAG = 2;
            Scanner input = new Scanner(System.in);
            String goods = input.next();
            // 退還物品
            coordinator.handler(2,goods);
        }
        // 否則就是繼續交流
        ConsreteConnrdinator.MSG_FLAG = 2;
        Scanner input = new Scanner(System.in);
        coordinator.handler(1,input.next());
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

5、測試

package com.zixieqing;

import com.zixieqing.o1simple.ConsreteConnrdinator;
import com.zixieqing.o1simple.Coordinator;
import com.zixieqing.o1simple.Man;
import com.zixieqing.o1simple.Woman;

/**
 * <p>@description  : 該類功能  測試
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ApiTest {

    public static void main(String[] args) {

        Coordinator connrdinator = new ConsreteConnrdinator();

        Woman woman = new Woman(connrdinator);
        // 同事類的獨有方法
        woman.shopping();

        Man man = new Man(connrdinator);
        // 同事類獨有方法
        man.eat("閉門羹");
        man.drink("寂寞");
        man.cook("空氣");

        // 提供給外部，進行協調的方法
        woman.talkToFriend("");
        // 提供給外部，進行協調的方法
        man.love("");
    }
}

自娛自樂的聊天室就來了

當然：中介者被稱為協調者，那也得協調協調，做點事情嘛，不能只當個傳話筒，這個就根據開發場景自由發揮了

同時：上面的同事類是可以抽離成一個介面，變成抽象同事類+實現類

分析一丟丟中介者模式：

1、每個同事類物件只與中介者產生依賴關係，同事類彼此之間不產生依賴
2、具體協調者中加入了用private修飾的用於處理各同事類關係的方法，從而讓一個物件依賴多個物件的情況移到這個中介者中來進行處理了
3、同事類中都加入了中介者，從而讓各個同事類都具有中介者的特性，這樣做之後：各個同事類就可以只負責自己的行為（獨有方法），而不需要自己負責的 / 需要協調的就丟給中介者進行處理（這樣做也取消了各個同事類之間產生依賴或關聯關係）
- 同事類只負責自己的行為，不需要負責的就丟給中介者處理，這樣好處就是：各個同事類之間可以不用知道彼此的存在，它只需要和中介者打交道即可
- 同事類只負責自己的行為，需要協調的就丟給中介者進行處理，這樣可能會造成這個模式濫用的情況（慎用），因為這樣做一不注意就可能導致：同事類之間知道彼此的存在了，即：各同事類之間一不注意就產生關聯或依賴關係，那這模式架構就當白做了（別被我上面弄的男女耍朋友給搞混了，誰跟你說他們知道彼此存在的，我沒說，萬一這裡面有故事呢）

當然上面這些都可以說是中介者模式的優點，相應地就有缺點

原本是各個同事類之間產生依賴或關聯關係，現在是變成同事類和中介者之間產生依賴關係，這樣就造成：同事類越多，那麼中介者就越腫大（需要聚合的同事類就變多，核心方法[事件方法]中需要處理的邏輯就越複雜），這個缺點也是決定到底要不要用中介者模式的核心，否則就成為亂整，要用這個模式就一定要考慮是否會讓中介者變得腫大的問題

3.2.5、備忘錄模式

定義：備忘錄模式又稱為快照模式，備忘、備忘嘛，指的就是在不破壞封裝性的前提下，獲取到一個物件的內部狀態，並在物件之外記錄或儲存這個狀態，在有需要的時候可將該物件恢復到原先儲存的狀態。使用備忘錄模式可以對操作物件提供回滾操作，但對資源消耗過大，每操作一次都需要記錄操作前資料

人話：就是為了防丟失、復原、恢復等事情的（即：需要記錄一個物件的內部狀態，目的就是為了允許使用者取消不確定或者錯誤的操作，能夠恢復到他原先的狀態，有 "後悔藥" 可吃，這也是這個模式的適用場景）

注意上面的官方話定義：

獲取物件內部狀態（內部還有什麼狀態，就屬性值唄），並在物件之外儲存這個狀態（即：在要儲存的物件中會有一個save方法用來把其當前屬性值儲存到另一個物件[即：備忘錄物件]中

在有需要時可將物件恢復到原先儲存的狀態：也就是說在要儲存物件中還會有一個提供和復原 / 回滾類似的方法，從而讓物件回到上一步的狀態

備忘錄模式的角色

備忘錄（Memento）：負責儲存發起人的內部狀態，在需要的時候提供這些內部狀態給發起人
發起人（Originator）：需要備忘的物件，記錄當前時刻的內部狀態資訊，提供將當前時刻的內部狀態狀態資訊儲存到備忘錄中，並將備忘錄物件返回以及從備忘錄中記錄的狀態資訊恢復此物件狀態的方法
負責人（Caretaker）：用於管理備忘錄，提供儲存與獲取備忘錄物件的功能（getter、setter），但其不能直接對備忘錄中的內容進行操作（要操作備忘錄中的內容只能找備忘錄本身才可以）

備忘錄模式邏輯關係草圖

3.4.5.1、簡單邏輯

1、備忘錄：儲存發起人的內部狀態資訊，並在需要時能將資料交出去

package com.zixieqing.o1simple;

/**
 * <p>@description  : 該類功能  備忘錄：儲存發起人的內部狀態資訊，並在需要時能夠將儲存的資料交出去
 * </p>
 * <p>@package      : com.zixieqing.o1simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Memento {
    private Object state;

    public Memento(Object state) {
        this.state = state;
    }

    public Object getState() {
        return state;
    }
}

2、負責人：管理備忘錄，提供獲取、儲存備忘錄物件的方法，但不可對備忘錄中的內容進行操作

package com.zixieqing.o1simple;

/**
 * <p>@description  : 該類功能  負責人：管理備忘錄，提供獲取、儲存備忘錄物件的方法，但不可以對備忘錄中的內容進行操作
 * </p>
 * <p>@package      : com.zixieqing.o1simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Caretaker {

    private Memento memento;

    public Memento getMemento() {
        return memento;
    }

    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}

3、發起人：要進行備忘的物件，記錄當前時刻的內部屬性資訊到備忘錄中並返回備忘錄物件，同時在需要時可從備忘錄中恢復當前物件的內部資訊

package com.zixieqing.o1simple;

/**
 * <p>@description  : 該類功能  發起人：需要進行備忘的物件，記錄當前時刻的內部屬性資訊到備忘錄中，並返回備忘錄物件
 * 並在需要時可從備忘錄中記錄的狀態資訊恢復資料
 * </p>
 * <p>@package      : com.zixieqing.o1simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Orginal {

    private Object field;

    /**
     * 儲存當前時刻的狀態資訊到備忘錄中，並返回備忘錄物件
     */
    public Memento saveToMemento() {
        return new Memento(this.field);
    }

    /**
     * 從備忘錄中恢復當前物件的內部狀態資訊
     * @param memento 備忘錄
     */
    public void rollbackFromMemento(Memento memento) {
        this.field = memento.getState();
    }


    @Override
    public String toString() {
        return "Orginal{" +
                "field=" + field +
                '}';
    }

    public Object getField() {
        return field;
    }

    public void setField(Object field) {
        this.field = field;
    }
}

4、測試

package com.zixieqing;

import com.zixieqing.o1simple.Memento;
import com.zixieqing.o1simple.Orginal;

/**
 * <p>@description  : 該類功能  測試
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ApiTest {

    public static void main(String[] args) {

        // 要進行儲存的物件
        Orginal orginal = new Orginal();
        orginal.setField("稀里嘩啦儲存了一堆的東西");

        // 將物件的當前時刻的內部資訊儲存到備忘錄中
        Memento memento = orginal.saveToMemento();

        System.out.println(orginal);

        // 模擬
        orginal.setField("噼裡啪啦又是一頓操作，儲存了資料");
        System.out.println(orginal);

        System.out.println("=============蕪湖~斷電咯================");
        System.out.println("。。。。。。。。。。。。。。。。。。。。");
        System.out.println("=============耶吼~電力恢復啦=============");

        // 從記錄的備忘錄中恢復物件內部狀態
        orginal.rollbackFromMemento(memento);

        System.out.println("=============物件恢復之後的狀態===========");
        System.out.println(orginal);
    }
}

備忘錄模式的缺點：

如果要儲存的物件的內部狀態資訊（屬性）很多的話，那記憶體資源消耗是很大的，所以有時可以使用單例、命令模式這些來進行資料儲存，當然更可以通過第三方中介軟體儲存

* 3.2.6、觀察者模式

定義：指的是多個觀察者同時監聽一個主題物件，每當主題物件發生變化時，都會通知監聽 / 依賴它的所有觀察者，從而讓觀察者自動更新自身相關的資料。因此主題物件和觀察者之間就是一對多的依賴關係（這定義就是它的適用場景）

核心：將觀察者和被觀察者進行了解耦，並通過類似於訊息傳送的機制讓兩者進行聯動，從而做到被觀察者發生變化時，監聽 / 依賴於它的所有觀察者都會得到通知並做出響應（更新自身資料）

觀察者模式的角色（可以當做釋出訂閱模式來理解，但：這二者不能完全等價，釋出訂閱模式在觀察者和被觀察者之間再套了一層[套的這一層就是釋出訂閱中的事件機制 Event Channel]，自行面向百度程式設計）：

抽象主題（Subject）：被觀察的物件，是介面或抽象類。也就是釋出者，包含了：增加、刪除、通知觀察者物件的方法
具體主題（ConcreteSubject）：具體被觀察者，是抽象主題的子類。當其內部狀態發生改變時會通知所有依賴與它的觀察者
抽象觀察者（Observer）：觀察者模型，也就是訂閱者，定義了響應通知的更新方法
具體觀察者（ConcreteObserver）：是抽象觀察者的子類，在收到主題物件狀態發生改變的通知後，會立刻對其進行響應，並更新自身的相關資料

觀察者模式邏輯草圖

3.2.6.1、簡單邏輯

場景：博主與粉絲，博主發文章，粉絲收到通知

1、先決條件：文章類

package com.zixieqing.o1simple;

import lombok.Data;
import lombok.ToString;
import lombok.experimental.Accessors;

import java.util.Date;

/**
 * <p>@description  : 該類功能  文章
 * </p>
 * <p>@package      : com.zixieqing.o1simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

@Data
@ToString
@Accessors(chain = true)
public class Article {

    /**
     * 文章標題
     */
    private String title;

    /**
     * 文章內容
     */
    private String context;

    /**
     * 釋出人編號
     */
    private Long publisherId;

    /**
     * 釋出時間
     */
    private Date createTime;

    /**
     * 文章所屬標籤
     */
    private String articleLabel;

}

2、博主介面：抽象主題即釋出者，包含增加、刪除、通知觀察者物件等方法

package com.zixieqing.o1simple;

/**
 * <p>@description  : 該類功能  博主介面：抽象主題 包含增加、刪除、通知觀察者物件的方法
 * </p>
 * <p>@package      : com.zixieqing.o1simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface IBlogger {

    /**
     * 將粉絲新增到通知列表中，能夠讓粉絲接受到通知
     * @param fan 粉絲
     * @return true / false
     */
    boolean add(IFan fan);

    /**
     * 將粉絲拉入黑名單，不讓其接收到通知
     * @param fan 粉絲
     * @return true / false
     */
    boolean remove(IFan fan);

    /**
     * 通知觀察者
     * @param article 訊息體
     */
    void notice(Article article);
}

具體博主：具體主題

package com.zixieqing.o1simple.impl;

import com.zixieqing.o1simple.Article;
import com.zixieqing.o1simple.IBlogger;
import com.zixieqing.o1simple.IFan;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * <p>@description  : 該類功能  一個叫紫邪情的厚臉皮博主
 * </p>
 * <p>@package      : com.zixieqing.o1simple.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Zixieqing implements IBlogger {

    private Logger logger = LoggerFactory.getLogger(Zixieqing.class);

    /**
     * 粉絲列表：一對多
     */
    private List<IFan> fanList = new ArrayList<>();

    @Override
    public boolean add(IFan fan) {
        if (!fanList.contains(fan))
            return fanList.add(fan);

        return false;
    }

    @Override
    public boolean remove(IFan fan) {
        if (!add(fan))
            return fanList.remove(fan);

        return false;
    }

    @Override
    public void notice(Article article) {
        for (IFan fan : fanList) {
            fan.response(article);
        }
    }
}

注：還是補上吧，上面通知的方法，若是再加上"滿足什麼條件就觸發通知方法"，把這句話再進行抽取一下搞到另外合適的地方去，就變成了觸發機制，即：被觀察者滿足什麼條件觸發通知，從而讓所依賴的所有觀察者都收到通知，並更新自身相關資料。這裡抽取出來的觸發機制就是事件通道Event channel，抽取出來之後，這個觀察者模式就可以變成釋出-訂閱模式了

3、粉絲介面：即訂閱者得到通知之後進行響應並改變自身和主題相關的資料

package com.zixieqing.o1simple;

/**
 * <p>@description  : 該類功能  粉絲介面：抽象觀察者 得到通知之後，更新自身相關資料 / 做自己要做的事情
 * </p>
 * <p>@package      : com.zixieqing.o1simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public abstract class IFan {

    public abstract boolean response(Article article);
}

具體粉絲Q

package com.zixieqing.o1simple.impl;

import com.zixieqing.o1simple.Article;
import com.zixieqing.o1simple.IFan;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * <p>@description  : 該類功能  一個叫Q的粉絲
 * </p>
 * <p>@package      : com.zixieqing.o1simple.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class QFan extends IFan {

    private Logger logger = LoggerFactory.getLogger(QFan.class);

    /**
     * 粉絲感興趣的博文列表
     */
    private static List<String> interestList = new ArrayList<>();
    static {
        interestList.add("設計模式");
        interestList.add("愛碼有道");
        interestList.add("Java");
    }

    @Override
    public boolean response(Article article) {
        for (String interest : interestList) {
            if (article.getTitle().equals(interest)) {
                logger.info("粉絲：{}，接收了通知：{}，並開始去做一系列和自身資料相關的事情",
                        this.getClass().getSimpleName(),
                        article);
                return true;
            }
        }
        return false;
    }
}

具體粉絲X

package com.zixieqing.o1simple.impl;

import com.zixieqing.o1simple.Article;
import com.zixieqing.o1simple.IFan;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * <p>@description  : 該類功能  一個叫X的粉絲
 * </p>
 * <p>@package      : com.zixieqing.o1simple.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class XFan extends IFan {

    private Logger logger = LoggerFactory.getLogger(XFan.class);

    /**
     * 粉絲感興趣的博文列表
     */
    private static List<String> interestList = new ArrayList<>();
    static {
        interestList.add("訊息中介軟體");
        interestList.add("愛碼有道");
        interestList.add("分散式事務");
        interestList.add("分散式事務");
    }

    @Override
    public boolean response(Article article) {
        for (String interest : interestList) {
            if (article.getTitle().equals(interest)) {
                logger.info("粉絲：{}，接收了通知：{}，並開始去做一系列和自身資料相關的事情",
                        this.getClass().getSimpleName(),
                        article);
                return true;
            }
        }
        return false;
    }
}

4、測試

package com.zixieqing;

import com.zixieqing.o1simple.Article;
import com.zixieqing.o1simple.IBlogger;
import com.zixieqing.o1simple.impl.QFan;
import com.zixieqing.o1simple.impl.XFan;
import com.zixieqing.o1simple.impl.Zixieqing;

import java.util.Date;

/**
 * <p>@description  : 該類功能  測試
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ApiTest {
    public static void main(String[] args) {
        IBlogger blogger = new Zixieqing();

        // 讓指定粉絲能收到通知
        QFan qFan = new QFan();
        XFan xFan = new XFan();
        blogger.add(qFan);
        blogger.add(xFan);

        // 博主開始寫文章
        Article article = new Article();
        String context = "設計莫斯一共有23種，分為建立型、行為型、結構型，這三類其實就是不同層別的架構，" +
                "如：建立型就是專門用於new範例的架構；即：物件，而行為型體現在行為上，也就是所謂的方法，" +
                "變來變去其實本質就是對類中方法的架構" +
                "學完全部設計模式之後，感受就會起來了，然後只需要知曉每個設計模式解決的場景是什麼，" +
                "最後開發中遇到對應的設計模式場景就套用，然後思路就出來，也熟練了";
        article.setTitle("設計模式")
                .setPublisherId(System.nanoTime())
                .setContext(context)
                .setArticleLabel("設計")
                .setCreateTime(new Date());

        // 將文章推給粉絲
        blogger.notice(article);


        System.out.println("=============華麗的分隔符===============");

        // blogger.remove(xFan);
        article.setTitle("愛碼有道")
                .setPublisherId(System.nanoTime())
                .setContext("正式開發時還是遵循開發規範比較好")
                .setArticleLabel("程式碼整潔")
                .setCreateTime(new Date());

        // 將文章推給粉絲
        blogger.notice(article);
    }
}

3.2.6.2、分析觀察者模式

觀察者模式的優點

被觀察者（Subject主題）和觀察者（Observer）是鬆耦合的，包含關係嘛，同時也是面向介面程式設計的（即：符合依賴倒置原則）

將表示層（觀察者）和資料邏輯層（被觀察者）進行了分離，只要被觀察者的自身狀態發生改變就可以讓觀察者相應的資料也發生改變，即：制定了一套觸發機制，從而做到資料邏輯層的資料變化可以相應到多個表示層上
使用了一對多的機制，被觀察者的狀態發生改變，只有滿足同一套觸發機制的觀察者才能接收到通知，這樣的機制可以做很多事，比如：興趣分發、事件註冊等機制

觀察者模式的缺點

因為觀察者是被放在被觀察者的一個容器中，那眾多的觀察者在這個容器中就產生了類似於鏈化的情況，而只要是容器那就逃不開遍歷的事（像連結串列一樣，或者說線性關係更恰當），這就有缺點了，若是觀察者很多的話，那通知所有的觀察者就需要耗費時間了

基於前面的線性關係的情況，還有造成一個問題：只要一個觀察者沒處理好，導致出現卡死的情況，那麼後續的觀察者也別通知了（換言之：後續觀察者可能出現接收不到通知的情況），相當於後續觀察者死翹翹了

* 3.2.7、狀態模式

定義：一個物件在其內部狀態改變時改變它的行為

解決的問題：解決複雜物件的狀態轉換以及不同狀態下行為的封裝問題，一句話：物件在不同狀態下有不同行為時就可以使用狀態模式

核心：將一個物件的狀態從該物件中分離出來，封裝到專門的狀態類中（抽象狀態+實現類），從而使得物件狀態可以靈活變化

本質：在程式碼中對物件屬性進行的大量if-else判斷進行抽離（如程式碼：if(p.getxxxx().equals("yyyy")){}，狀態模式解決的差不多就是這種程式碼)，在物件內部提供外部呼叫的方法，從而讓其自身根據狀態的不同去走對應的邏輯（狀態實現類中的邏輯），如：一個介面登入是一種樣子，未登入又是另一種樣子，狀態不同行為不同。這也是這個模式的適用場景，即：程式碼中包含大量與物件狀態有關的條件語句時（if-else和switch）就可以使用狀態模式進行改造

狀態模式的角色

上下文（Context）：狀態所屬者，維護具體狀態類的範例，這個範例儲存其當前狀態
抽象狀態（State）：封裝與Context的一個特定狀態相關的行為操作（這裡面可以定義多個方法的，這是和命令模式的一個小區別）
具體狀態（ConcreteState）：每一個具體的狀態類實現一個與Context的一個狀態相關的行為，在需要時也可以進行狀態切換

狀態模式的邏輯草圖

3.2.7.1、簡單邏輯

場景：去ATM中取款

1、抽象狀態：ATM狀態對應的行為封裝

package com.zixieqing;

/**
 * <p>@description  : 該類功能  抽象狀態：ATM狀態對應的行為
 * 封裝與Context狀態所屬者的狀態 / 屬性相關的行為
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface ATMState {
    /**
     * 插卡
     */
    void insertCard();

    /**
     * 提交密碼
     */
    void submitPwd();

    /**
     * 取款
     */
    void getCash();

    /**
     * 查詢餘額
     */
    void queryBalance();

    /**
     * 退卡
     */
    void checkOut();
}

2、具體狀態

準備狀態

package com.zixieqing.impl;

import com.zixieqing.ATMContext;
import com.zixieqing.ATMState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>@description  : 該類功能  具體狀態：準備狀態
 * 具體狀態：1、實現Context的一個狀態的相關行為邏輯
 *         2、在需要時進行狀態切換
 *              狀態切換可以是本狀態中的不同行為切換，也可以是切換到不同具體狀態者
 * </p>
 * <p>@package      : com.zixieqing.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ReadyState implements ATMState {

    private Logger logger = LoggerFactory.getLogger(ReadyState.class);

    /**
     * 依賴：保留狀態所屬者Context的參照，作用：方便對其進行操作
     *      介面ATMState 是對狀態進行了抽象
     *      實現類（ReadyState或其他實現類）是具體的狀態
     * 這些具體狀態者（實現類）都只是狀態本身而已，而狀態所屬者是Context，最後狀態是要回到所屬者身邊的
     * 如果這個具體狀態者中沒有 對 狀態所屬者Context進行相應操作，那：具體狀態者 和 狀態所屬者就是割裂 / 分開的
     */
    private ATMContext atmContext;

    public ReadyState(ATMContext atmContext) {
        this.atmContext = atmContext;
    }

    @Override
    public void insertCard() {
        logger.info("完成插卡");
    }

    @Override
    public void submitPwd() {
        logger.info("正在進行密碼校驗............");
        if ("123456".equals(atmContext.getPwd())) {
            logger.info("密碼校驗成功");
        }else {
            logger.info("密碼不正確");
            // 狀態切換：退卡 / 重新進入準備狀態..........
            checkOut();
        }
    }

    @Override
    public void getCash() {
        // 如果ATM中沒錢了，那就不能再提供服務
        if (atmContext.getATMBalance() == 0) {
            logger.info("無法使用服務，請去另外機子進行業務辦理");

            // 彈卡
            checkOut();

            /*
                狀態切換
                注意這裡：這裡沒有用new，而是用的atmContext的setter，這也是前面說保留atmContext參照的好處之一
                好處：降低耦合（迪米特原則：最少知道原則），獲取彈性
             */
            atmContext.setCurrState(atmContext.getNoServiceState());
        }else {
            if (atmContext.getMoney() <= atmContext.getATMBalance() && atmContext.getMoney() <= atmContext.getBalance()) {
                // 出鈔、減少使用者的賬戶餘額
                logger.info("出鈔￥：{}",atmContext.getMoney());
                atmContext.setBalance(atmContext.getBalance() - atmContext.getMoney());

                // 減少ATM中的鈔票金額
                atmContext.setATMBalance(atmContext.getATMBalance() - atmContext.getMoney());

                // 列印發票、回到準備狀態...........

                // 彈卡
                checkOut();
            }else {
                logger.info("餘額不足");
                checkOut();
            }
        }
    }

    @Override
    public void queryBalance() {
        logger.info("賬戶餘額為：{}", atmContext.getBalance());
    }

    @Override
    public void checkOut() {
        logger.info("退卡成功");
    }
}

無法提供服務狀態

package com.zixieqing.impl;

import com.zixieqing.ATMContext;
import com.zixieqing.ATMState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>@description  : 該類功能  具體狀態：停止服務
 * </p>
 * <p>@package      : com.zixieqing.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class NoServiceState implements ATMState {

    private ATMContext atmContext;

    public NoServiceState(ATMContext atmContext) {
        this.atmContext = atmContext;
    }

    private Logger logger = LoggerFactory.getLogger(NoServiceState.class);

    @Override
    public void insertCard() {
        logger.info("服務停止，請去其他取款機進行業務辦理");
    }

    @Override
    public void submitPwd() {
        logger.info("服務停止，請去其他取款機進行業務辦理");
    }

    @Override
    public void getCash() {
        logger.info("服務停止，請去其他取款機進行業務辦理");
    }

    @Override
    public void queryBalance() {
        logger.info("服務停止，請去其他取款機進行業務辦理");
    }

    @Override
    public void checkOut() {
        logger.info("服務停止，請去其他取款機進行業務辦理");
    }
}

3、核心：Context上下文物件

package com.zixieqing;

import com.zixieqing.impl.NoServiceState;
import com.zixieqing.impl.ReadyState;
import lombok.Data;
import lombok.ToString;
import lombok.experimental.Accessors;

/**
 * <p>@description  : 該類功能  Context上下文物件（這個Context是核心）
 * 狀態所屬者：1、維護具體狀態者範例；
 *           2、也可以有它自己的特有狀態；
 *           3、將狀態改變時其對應的行為交給對應的狀態物件，即：狀態改變時讓其走對應的邏輯（供外部呼叫的）
 * 上面2、3根據情況決定可有可無
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

@Data
@ToString
@Accessors(chain = true)
public class ATMContext {

    // 假設此Context物件有如下的獨有狀態（實質是：老衲待會兒測試需要，一次性寫在這裡了）
    /**
     * 密碼
     */
    private String pwd;

    /**
     * 使用者取款金額
     */
    private int money;

    /**
     * 使用者的賬戶餘額（假設為int型別）
     */
    private int balance;

    /**
     * ATM機中的鈔票餘額
     */
    private int ATMBalance;

    // 下面這些就是這個Context所維護的具體狀態者範例
    /**
     * 當前狀態
     */
    private ATMState currState;
    /**
     * 準備狀態
     */
    private ATMState readyState;
    /**
     * 無服務狀態
     */
    private ATMState noServiceState;

    /**
     * 初始化所有狀態
     * @param pwd 密碼
     * @param money 使用者取款金額
     * @param balance 使用者的賬戶餘額
     * @param ATMBalance ATM機中的鈔票餘額
     */
    public ATMContext(String pwd, int money, int balance, int ATMBalance) throws Exception {
        this.pwd = pwd;
        this.money = money;
        this.balance = balance;
        this.ATMBalance = ATMBalance;

        this.readyState = new ReadyState(this);
        this.noServiceState = new NoServiceState(this);
        if (this.getATMBalance() > 0) {
            this.currState = readyState;
        } else if (this.getATMBalance() < 0) {
            this.currState = noServiceState;
        }else {
            throw new Exception();
        }
    }

    // 下面這些就是這個Context在其狀態改變時將具體行為委託給具體狀態物件（可以直接供外部呼叫）

    /**
     * 轉換到插卡行為
     */
    public void insertCard() {
        this.currState.insertCard();
    }

    /**
     * 提交密碼
     */
    public void submitPwd() {
        this.currState.submitPwd();
    }

    /**
     * 取款
     */
    public void getCash() {
        this.currState.getCash();
    }

    /**
     * 查詢餘額
     */
    public void queryBalance() {
        this.currState.queryBalance();
    }

    public void checkOut() {
        this.currState.checkOut();
    }
}

4、測試

package com.zixieqing;

/**
 * <p>@description  : 該類功能  測試
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ApiTest {
    public static void main(String[] args) throws Exception {

        ATMContext atmContext = new ATMContext("123456", 300, 200000, 100000);

        System.out.println("===============初始狀態===================");
        System.out.println(atmContext);

        atmContext.insertCard();
        atmContext.submitPwd();
        atmContext.getCash();
        atmContext.queryBalance();
        atmContext.checkOut();

        System.out.println("===============結束狀態===================");
        System.out.println(atmContext);
    }
}

結果

===============初始狀態===================
ATMContext(pwd=123456, money=300, balance=200000, ATMBalance=100000, currState=com.zixieqing.impl.ReadyState@5d6f64b1, readyState=com.zixieqing.impl.ReadyState@5d6f64b1, noServiceState=com.zixieqing.impl.NoServiceState@32a1bec0)
17:50:01.410 [main] INFO  com.zixieqing.impl.ReadyState - 完成插卡
17:50:01.413 [main] INFO  com.zixieqing.impl.ReadyState - 正在進行密碼校驗............
17:50:01.413 [main] INFO  com.zixieqing.impl.ReadyState - 密碼校驗成功
17:50:01.413 [main] INFO  com.zixieqing.impl.ReadyState - 出鈔￥：300
17:50:01.413 [main] INFO  com.zixieqing.impl.ReadyState - 退卡成功
17:50:01.413 [main] INFO  com.zixieqing.impl.ReadyState - 賬戶餘額為：199700
17:50:01.413 [main] INFO  com.zixieqing.impl.ReadyState - 退卡成功
===============結束狀態===================
ATMContext(pwd=123456, money=300, balance=199700, ATMBalance=99700, currState=com.zixieqing.impl.ReadyState@5d6f64b1, readyState=com.zixieqing.impl.ReadyState@5d6f64b1, noServiceState=com.zixieqing.impl.NoServiceState@32a1bec0)

3.2.7.2、分析狀態模式

狀態模式的優點

消除了使用物件屬性的條件分支語句（if-else或switch），通過Context狀態所屬者中的狀態行為託管，將屬性 / 狀態的邏輯處理遷移到了State子類來進行，降低了相互間的依賴。使程式碼結構清晰的同時也易擴充套件和易維護
顯式化進行狀態轉換：為不同的狀態引入獨立的物件，使得狀態的轉換變得更加明確。而且狀態物件可以保證上下文不會發生內部狀態不一致的狀況，因為上下文中只有一個變數來記錄狀態物件，只要為這一個變數賦值就可以了

將所有與某個狀態有關的行為放到一個類中，並且可以方便地增加新的狀態，只需要改變物件狀態即可改變物件的行為

狀態模式的缺點

因為此模式就是讓物件隨著其狀態改變而改變行為，從而讓其本身看起來像改變了一樣，這其實就違背了「開閉原則」，因為若是新增新的具體狀態類，那就需要在Context中維護此具體狀態範例（修改負責狀態轉換的原始碼），否則就無法切換到新增狀態

狀態模式的結構和實現邏輯一般都是很複雜的，如果一不注意搞不好就會導致程式結構和程式碼混亂

使用狀態模式的建議：

1、具體狀態類一般不要超過5個左右，不然維護起來也是很麻煩的，因為每一個具體狀態類中不同行為邏輯本身就很複雜，而且不同行為之間會進行切換，甚至會切換到另外的狀態去，例子如下（這還不是複雜的，一般真要用這個模式時複雜程度不算低）：

3.2.7.3、狀態模式 VS 命令模式

這兩個模式的思路，或者說結構吧，是有點像的，但還是有區別的，還有一個策略模式，但這個還沒玩呢，後續比較時再加入

狀態模式和命令模式最大的區別是下面這些

首先第一點：狀態模式中在抽象狀態中是可以定義很多方法的，而命令模式的抽象命令中一般都是一個方法

其次第二點：要區分開二者的定義
- 狀態模式：Context狀態所屬者自己內部維護著狀態，會隨著公共方法（前面範例中哪些供外部呼叫的，如：下圖的）的呼叫而切換狀態，外界不需要知道狀態的真實變化情況（變化情況實質在具體狀態類中，會根據情況進行狀態切換）
- 命令模式：根據請求封裝相應的命令，請求發起者不需要知道真正的命令是什麼、該怎麼處理（如：電視換臺，只需要按下相應按鈕，這按鈕對應的底層命令是什麼、會怎麼進行處理，按下按鈕的人不需要知道），只需要去呼叫抽象命令中的execute()介面就行（當然：也不是一定要叫這個介面名

* 3.2.8、策略模式

定義：又名政策模式（Policy），指的是針對一組演演算法，將每一個演演算法封裝到具有共同介面的獨立的類中，使得它們可以互換（實現同一個介面：里氏替換原則），可以讓演演算法隨著呼叫者的變化而變化

解決的問題 / 適用場景：在有多種演演算法相似（同類可替代的行為邏輯演演算法）的情況下，去掉使用條件分支語句（if-else或switch）所帶來的複雜性和難以維護

場景理解：不同型別的交易方式（微信、支付寶、銀行卡）；生成唯一主鍵策略（UUID、DB自增、DB自增+Redis、Leaf演演算法），這些就可以使用策略模式對不同的行為進行封裝，供外部呼叫

策略模式的角色

上下文 / 環境類（Context）：負責查詢要做什麼。這裡面也可以封裝著具體策略物件需要的資料，具體策略物件通過回撥上下文的方法來獲取這些資料，這玩意兒可以在必要時當做引數（即：關聯）傳給具體策略物件
抽象策略（Strategy）：演演算法的抽象 / 演演算法的規範。介面或抽象類都可以
具體策略（ConcreteStrategy）：具體的某一個演演算法 / 行為實現。若是有必要可以從上下文中回撥它裡面的方法來獲取所需要的資料

策略模式的邏輯草圖（可以對照命令模式來看，二者結構很像的）

3.2.8.1、簡單邏輯

場景：就用上面說的不同型別交易方式（微信、支付寶）

1、上下文Context：在必要時儲存具體策略需要的資料；負責呼叫者要做什麼

package com.zixieqing;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>@description  : 該類功能  上下文 / 環境類
 *                      1、可以在必要時儲存具體策略物件需要的資料
 *                      2、負責呼叫者要做什麼
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class PayContext {
    private Logger logger = LoggerFactory.getLogger(PayContext.class);

    private PayStrategy payStrategy;

    /**
     * 讓呼叫者自己決定用哪種支付策略
     * @param payStrategy 支付方式
     */
    public PayContext(PayStrategy payStrategy) {
        this.payStrategy = payStrategy;
    }

    /**
     * 負責要做什麼：支付
     */
    public void pay() {
        this.payStrategy.pay();
    }
}

2、抽象策略：對同組不同演演算法進行抽象，制定規範

package com.zixieqing;

/**
 * <p>@description  : 該類功能  抽象策略：對同組不同演演算法進行抽象
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface PayStrategy {

    void pay();
}

微信支付

package com.zixieqing.impl;

import com.zixieqing.PayStrategy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>@description  : 該類功能  具體策略：微信支付方式
 * </p>
 * <p>@package      : com.zixieqing.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class WeChatPayImpl implements PayStrategy {

    private Logger logger = LoggerFactory.getLogger(WeChatPayImpl.class);

    @Override
    public void pay() {
        logger.info("本微信系統：收到商戶平臺中傳來的 建立訂單請求");
        logger.info("本微信系統：正在建立 預付單");
        logger.info("本微信系統：預付單生成成功：返回商戶平臺預付單標識");

        logger.info("這中間就是商戶平臺生成帶簽名的支付資訊、使用者發起支付請求、商戶平臺找微信使用者端調起微信支付");

        logger.info("本微信系統：收到微信使用者端(即：微信APP)發起的支付請求，開始驗證支付授權許可權");
        logger.info("本微信系統：給微信使用者端返回支付授權");

        logger.info("使用者：確認支付、輸入密碼，即提交授權給本微信支付系統");

        logger.info("本微信系統：正在驗證支付授權");

        logger.info("本微信系統：非同步通知商戶平臺：支付結果");

        logger.info("商戶平臺：儲存支付通知，並返回本微信支付系統成功接收、處理與否");

        logger.info("本微信系統：給微信使用者端返回支付結果，並行微信訊息提醒（即：微信中的那個微信支付的訊息）");

        logger.info("最後就是另外的一堆邏輯處理情況");
    }
}

支付寶支付

package com.zixieqing.impl;

import com.zixieqing.PayStrategy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>@description  : 該類功能  具體策略：支付寶支付
 * </p>
 * <p>@package      : com.zixieqing.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class AliPayImpl implements PayStrategy {

    private Logger logger = LoggerFactory.getLogger(AliPayImpl.class);

    @Override
    public void pay() {
        logger.info("支付寶支付和微信支付邏輯差不多的，假設這裡就是一堆的支付寶支付邏輯，意思意思");
    }
}

3、測試

package com.zixieqing;

import com.zixieqing.impl.AliPayImpl;
import com.zixieqing.impl.WeChatPayImpl;

/**
 * <p>@description  : 該類功能  測試
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ApiTest {
    public static void main(String[] args) {
        PayContext payContext = new PayContext(new WeChatPayImpl());
        payContext.pay();

        System.out.println("==================華麗的分隔符====================");

        PayContext payContext1 = new PayContext(new AliPayImpl());
        payContext1.pay();
    }
}

結果

16:56:43.248 [main] INFO  com.zixieqing.impl.WeChatPayImpl - 本微信系統：收到商戶平臺中傳來的 建立訂單請求
16:56:43.250 [main] INFO  com.zixieqing.impl.WeChatPayImpl - 本微信系統：正在建立 預付單
16:56:43.250 [main] INFO  com.zixieqing.impl.WeChatPayImpl - 本微信系統：預付單生成成功：返回商戶平臺預付單標識
16:56:43.250 [main] INFO  com.zixieqing.impl.WeChatPayImpl - 這中間就是商戶平臺生成帶簽名的支付資訊、使用者發起支付請求、商戶平臺找微信使用者端調起微信支付
16:56:43.250 [main] INFO  com.zixieqing.impl.WeChatPayImpl - 本微信系統：收到微信使用者端(即：微信APP)發起的支付請求，開始驗證支付授權許可權
16:56:43.250 [main] INFO  com.zixieqing.impl.WeChatPayImpl - 本微信系統：給微信使用者端返回支付授權
16:56:43.250 [main] INFO  com.zixieqing.impl.WeChatPayImpl - 使用者：確認支付、輸入密碼，即提交授權給本微信支付系統
16:56:43.251 [main] INFO  com.zixieqing.impl.WeChatPayImpl - 本微信系統：正在驗證支付授權
16:56:43.251 [main] INFO  com.zixieqing.impl.WeChatPayImpl - 本微信系統：非同步通知商戶平臺：支付結果
16:56:43.251 [main] INFO  com.zixieqing.impl.WeChatPayImpl - 商戶平臺：儲存支付通知，並返回本微信支付系統成功接收、處理與否
16:56:43.251 [main] INFO  com.zixieqing.impl.WeChatPayImpl - 本微信系統：給微信使用者端返回支付結果，並行微信訊息提醒（即：微信中的那個微信支付的訊息）
16:56:43.251 [main] INFO  com.zixieqing.impl.WeChatPayImpl - 最後就是另外的一堆邏輯處理情況
==================華麗的分隔符====================
16:56:43.251 [main] INFO  com.zixieqing.impl.AliPayImpl - 支付寶支付和微信支付邏輯差不多的，假設這裡就是一堆的支付寶支付邏輯，意思意思

3.2.8.2、分析策略模式

策略模式的優點

首先就是它的適用場景就是優點：避免程式碼中使用多重條件分支語句來判定採用哪種策略方式，從而變為採用new的方式，即：物件導向

符合開閉原則，當要新增策略時，只需要去實現介面，然後編寫相應的策略邏輯即可
由於實現同一介面，同時在Context上下文中擁有介面的參照，所以方便使用者端對不同策略進行自由切換

策略模式的缺點

可能會造成過多的具體策略類，即：在需要的程式碼中可以需要new好多個具體策略類（可以通過後續玩的亨元模式來減少一定的物件數量）
因為具體採用哪種策略時使用者端來決定，所以：就會導致使用者端需要知道所有的具體策略類，並且知道這些具體策略類之間有什麼不同

3.2.8.3、策略模式 VS 狀態模式 VS 命令模式

狀態模式和命令模式已在前面玩狀態模式時進行了對比

3.2.8.3.1、策略模式 VS 狀態模式

這二者可以說是"親兄弟"，二者在結構上很像，但是二者有區別

最主要的區別在定義上，也就是適用場景
- 1、策略模式講究的是同組不同演演算法，從而讓這些相似的演演算法之間根據使用者端需要可以自由切換，具體演演算法之間沒有互動。即：策略模式講的是使用者端控制物件使用什麼策略。策略可自由切換是因為Context類中有Strategy策略類的參照（即：策略類之間依賴注入到Context類中)
- 2、狀態模式講究的是物件內部狀態時行為也跟著改變，同時這些行為、狀態之間可能有互動（即：狀態切換）。即：狀態模式講的是自動改變狀態（具體狀態類中會根據相關邏輯進行狀態切換）。可進行自動改變狀態是因為具體狀態類中有狀態所屬者Context的參照，從而在狀態子類中已根據情況進行狀態切換
其次區別於做的事情上
- 策略模式做的是同一件事情。如：前面的例子微信支付、支付寶支付，這些都是針對於支付方式這一件事
- 狀態模式在不同狀態下會做不同事情。如：前面的例子ATM在準備狀態、無服務狀態對於同一方法(插卡、提交密碼、取款......)做的都是不同的事情，方法之間不具有可替代性
然後就是對於Context這個核心的上下文物件
- 策略模式在具體策略類中並不持有Context的參照，只供Context本身使用
- 狀態模式在具體狀態類中會持有Context的參照，目的就是對Context類進行操作，從而讓狀態最後迴歸到Context這個所屬者身上（即：方便進行狀態切換）

3.2.8.3.2、策略模式 VS 命令模式

這二者在結構上"有點像"，命令模式可以抽象地認為是一種策略模式(命令模式多了一個"接收者") 且命令處理的問題也更復雜，二者區別如下：

首先從定義上來看：
- 策略模式：是同組不同演演算法。它認為"演演算法"是一個已經不可拆分的業務(即：一件事，如：支付)，只是這個業務有不同方式的實現而已，目的是為了讓每個"具體演演算法"獨立，並彼此之間可替代，讓使用者端來抉擇使用哪一種"演演算法"。所以：此模式的關注重心在於"演演算法"的可替代問題
- 命令模式：它是將動作進行解耦（即：將請求包裹在命令物件中傳給呼叫物件，由呼叫物件來找能處理該命令的物件進行處理），換言之：就是將一個動作分為了執行行為(命令物件)、執行物件(接收者角色)，讓這二者彼此獨立而不相互影響。所以：此模式的關注重心在於動作的解耦問題
負責點不同(策略模式的抽象策略+具體策略、命令的接收者[也可拆為抽象接收者+具體接收者])
- 策略模式：具體策略是一個完整的邏輯，對使用者端負責，所以具體策略要做即做完，同時一旦修改就意味著對"演演算法"的整體調整
- 命令模式：只對命令負責，至於請求是什麼跟它關係不大(如：前面範例的廚師，它只需要負責做菜即可，至於使用者請求是什麼關其叼事)；接收者可以不是一個完整的邏輯，事情沒做好不直接影響使用者端(影響的是命令物件)，所以修改它不需要使用者端操心(如：某個廚師可以不做某個菜、菜怎麼做不需要客戶單教他)
適用場景不同
- 策略模式：適用於"演演算法"要求變換的場景
- 命令模式：適用於解耦兩個有緊耦合關係的物件場合或多命令多復原的場景

* 3.2.9、模板模式

定義：模板模式也可以叫模板方法模式，指的是：在一個方法中定義一個演演算法的骨架(即：演演算法的結構)，而一些其他非公共的步驟推遲到子類中去實現

一句話：封裝公有部分，擴充套件非公有

場景理解：建房子。工地上會把地基、走線、水管.....通用的東西搭建好(毛坯房)，然後根據情況加壁櫃、加柵欄....這些有差異的就是其他接手了這個毛坯房的裝修者來弄

適用場景：有多個子類共有的方法，並且邏輯相同；當然對於重要的、複雜的方法，也可以使用模板模式

注意點：因為是在父類別中定義"演演算法"骨架，並實現一些公有操作，而子類是不可以改變這個"演演算法"骨架的，因此：模板方法一般加上final關鍵字，即：不可更改

模板方法模式的角色：

抽象模板(Template)：定義"演演算法"模板、公有的具體操作、抽象操作
具體模板(ConcreteTemplate)：抽象模板的子類，實現抽象操作(即：非公有部分的邏輯)

模板方法模式的邏輯草圖：

3.2.9.1、簡單邏輯

場景：搞豆漿，分為選原料、新增原料、浸泡、打碎，新增原料是非公有的(可為紅豆、綠豆、黑豆、赤小豆.........)

1、抽象模板

package com.zixieqing;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>@description  : 該類功能  抽象模板
 *                      1、定義模板方法    制定要做的這件事的演演算法結構
 *                      2、封裝公有部分 實現其邏輯
 *                      3、抽象非公有部分 等著子類來實現邏輯
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public abstract class AbstractSoyMilk {

    private Logger logger = LoggerFactory.getLogger(AbstractSoyMilk.class);

    /**
     * 模板方法：制定"演演算法"結構
     */
    protected final void make() {
        // 1、選擇原料
        choose();
        // 2、新增調料
        add();
        // 3、浸泡
        soak();
        // 4、打碎
        smashed();
    }

    /**
     * 新增調料：非公有邏輯交由子類來實現
     */
    protected abstract void add();

    /**
     * 選擇原料：封裝公有部分
     */
    protected void choose() {
        logger.info("{} 正在準備新增原料 ",this.getClass().getSimpleName());

        logger.info("正在選擇原料");
    }

    /**
     * 浸泡：封裝公有部分
     */
    protected void soak() {
        logger.info("{} 正在準備新增原料 ",this.getClass().getSimpleName());

        logger.info("正在進行浸泡！");
    }

    /**
     * 打碎：封裝公有部分
     */
    protected void smashed() {
        logger.info("{} 正在準備新增原料 ",this.getClass().getSimpleName());

        logger.info("正在進行打碎");
    }
}

2、具體模板

紅豆

package com.zixieqing;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>@description  : 該類功能  具體模板：對非公有部分進行實現
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class RedBeans extends AbstractSoyMilk{

    private Logger logger = LoggerFactory.getLogger(RedBeans.class);

    @Override
    protected void add() {

        logger.info("{} 正在準備新增原料 ",this.getClass().getSimpleName());

        logger.info("價值3個W的紅豆已新增");
    }
}

綠豆

package com.zixieqing;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>@description  : 該類功能  具體模板：對非公有部分進行實現
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class GreenBeans extends AbstractSoyMilk{

    private Logger logger = LoggerFactory.getLogger(GreenBeans.class);

    @Override
    protected void add() {
        logger.info("{} 正在準備新增原料 ",this.getClass().getSimpleName());

        logger.info("已經新增成功適合你顏色的綠豆");
    }
}

3、測試

package com.zixieqing;

/**
 * <p>@description  : 該類功能  測試
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ApiTest {

    public static void main(String[] args) {
        // 紅豆型豆漿
        AbstractSoyMilk redBeans = new RedBeans();
        redBeans.make();

        System.out.println("=====================華麗的分隔符==================");

        // 綠豆型豆漿
        AbstractSoyMilk greenBeans = new GreenBeans();
        greenBeans.make();
    }
}

結果

15:05:06.896 [main] INFO  com.zixieqing.AbstractSoyMilk - RedBeans 正在準備新增原料 
15:05:06.899 [main] INFO  com.zixieqing.AbstractSoyMilk - 正在選擇原料
15:05:06.899 [main] INFO  com.zixieqing.RedBeans - RedBeans 正在準備新增原料 
15:05:06.899 [main] INFO  com.zixieqing.RedBeans - 價值3個W的紅豆已新增
15:05:06.899 [main] INFO  com.zixieqing.AbstractSoyMilk - RedBeans 正在準備新增原料 
15:05:06.899 [main] INFO  com.zixieqing.AbstractSoyMilk - 正在進行浸泡！
15:05:06.899 [main] INFO  com.zixieqing.AbstractSoyMilk - RedBeans 正在準備新增原料 
15:05:06.899 [main] INFO  com.zixieqing.AbstractSoyMilk - 正在進行打碎
=====================華麗的分隔符==================
15:05:06.899 [main] INFO  com.zixieqing.AbstractSoyMilk - GreenBeans 正在準備新增原料 
15:05:06.899 [main] INFO  com.zixieqing.AbstractSoyMilk - 正在選擇原料
15:05:06.899 [main] INFO  com.zixieqing.GreenBeans - GreenBeans 正在準備新增原料 
15:05:06.899 [main] INFO  com.zixieqing.GreenBeans - 已經新增成功適合你顏色的綠豆
15:05:06.899 [main] INFO  com.zixieqing.AbstractSoyMilk - GreenBeans 正在準備新增原料 
15:05:06.899 [main] INFO  com.zixieqing.AbstractSoyMilk - 正在進行浸泡！
15:05:06.899 [main] INFO  com.zixieqing.AbstractSoyMilk - GreenBeans 正在準備新增原料 
15:05:06.899 [main] INFO  com.zixieqing.AbstractSoyMilk - 正在進行打碎

3.2.9.2、分析模板方法模式

模板方法模式的優點

提取公共程式碼，便於維護；封裝了不變部分，擴充套件可變部分
演演算法的結構由父類別控制，子類只實現部分邏輯。 即擴大了程式碼的複用，父類別中定義了模板方法、公有部分邏輯，子類在需要時可以直接複用

模板方法模式的缺點

對於可變部分，每一個不同的實現方式需要不同的類來實現(如：前面範例的紅豆、綠豆)，這樣類的個數變多時，系統就變得複雜

3.2.10、存取者模式

定義·：使用了一個存取者類，它改變了元素類的執行演演算法。通過這種方式，元素的執行演演算法可以隨著存取者改變而改變。 元素物件已接受存取者物件，這樣存取者物件就可以處理元素物件上的操作

解決的問題： 穩定的資料結構和易變的操作耦合問題(方式：在被存取的類裡面加一個對外提供接待存取者的介面)

適用場景： 需要對一個物件結構中的物件進行很多不同的並且不相關的操作，而需要避免讓這些操作"玷汙"這些物件的類(即：這些物件所在類的原有的資料結構)，使用存取者模式將這些封裝到類中。通俗易懂的話：就是一個東西不同的人看到的是不一樣的結果也可以用，如：公司查賬和稅務局查賬

存取者模式的角色

抽象元素(Element)： 接收存取者存取的方法
具體元素(ConcreteElement)： 抽象元素的子類，實現方法
抽象存取者(Visitor)： 定義存取每個具體元素的方法
具體存取者(ConcreteVisitor)： 抽象存取者的子類，對方法進行實現
物件結構(Subject Structure)： 定義維護/新增元素、提供存取者能夠存取所有元素的方法。注：這個是可以根據情況來變的
- 一是可以採用直接實現抽象介面，和抽象元素併為一個層次，然後裡面做物件結構相應的事情即可
- 二是可以直接起一個物件結構的類，這裡面一樣的做物件結構相應的事情即可

3.2.10.1、存取者模式是怎麼變出來的

1、首先知道原有資料結構指的是什麼。 肯定用過如下的程式碼

@Data
public class Person {

    private String name;

}


class Test{
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("紫邪情");

        System.out.println(person.getName());
    }
}

這整個Person就是資料結構，而name就是所謂的元素，而person.setName("紫邪情")就是對元素的操作，而存取者模式就是解決對這種資料結構中的物件(元素)進行很多不同且不相關的操作，從而避免這些操作"玷汙"這些物件(元素，如上面的name·)的類(如上面的Person)的原有資料結構(即：Person原來的結構)

2、抽象元素：接收存取者能夠存取的方法

要存取的就是元素，也就是要存取name，因此：對類的所有要進行不同且不相關操作的屬性進行抽象化

/**
 * <p>@description  : 該類功能  抽象元素：把原有物件的所有屬性 進行 抽象化
 *                      1、接收存取者存取的方法
 * </p>
 * <p>@package      : com.zixieqing.o1derive</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface People {

    /**
     * 接收存取者存取的方法   方法名不一定是這個，
     *  根據對要進行不同且不相關操作的屬性操作的抽象化命名即可
     * @param visitor 存取者
     */
    void accept(Visitor visitor);
}

把對原有資料結構中要進行不同且不相關操作的屬性進行抽象化了
具體元素：原有資料結構(原有類，如：Person)中要進行不同且不相關操作的屬性(如：name......)，這些每一個屬性就是一個具體元素(子類)，同時：這些子類都有存取者的參照，所以都能夠讓存取者存取了；相應地，具體元素中的構成就變成要對這個元素(屬性)進行的那些不同且不相關的操作(如：簡單的那種setter，但不是真搞這種無趣的操作)

package com.zixieqing.o1derive.impl;

import com.zixieqing.o1derive.People;
import com.zixieqing.o1derive.Visitor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>@description  : 該類功能  具體元素
 *                      1、讓存取者能夠對原有類中的屬性進行操作
 * </p>
 * <p>@package      : com.zixieqing.o1derive.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Name implements People {

    private Logger logger = LoggerFactory.getLogger(Name.class);

    @Override
    public void accept(Visitor visitor) {
        logger.info("{}這個類就是原來類中的屬性，這個{}類中就可以進行這個{}屬性的不同且不相關的操作", 
                this.getClass().getSimpleName(),
                this.getClass().getSimpleName(),
                this.getClass().getSimpleName().toLowerCase());
    }
}

3、存取者：提供存取所有元素的方法 存取所有元素，就是存取原有類(如：Perosn)的屬性，而現在屬性變成了一個單獨的類(即：具體元素)

import com.zixieqing.o1derive.impl.Name;

/**
 * <p>@description  : 該類功能  抽象存取者：提供能夠存取所有元素(原來類中屬性)的方法
 * </p>
 * <p>@package      : com.zixieqing.o1derive</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface Visitor {

    /**
     * 存取原有類的name屬性 / 存取name元素
     *      要是還有其他的就繼續加 如：sex........
     * @param name 要存取的元素
     */
    void visit(Name name);
}

具體存取者就是去存取元素，而元素的參照也有了，那執行

package com.zixieqing.o1derive.impl;

import com.zixieqing.o1derive.Visitor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>@description  : 該類功能  具體存取者
 * </p>
 * <p>@package      : com.zixieqing.o1derive.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ConcreteVisitor implements Visitor {

    private Logger logger = LoggerFactory.getLogger(ConcreteVisitor.class);

    @Override
    public void visit(Name name) {

        logger.info("{}存取者即將開始元素存取",this.getClass().getSimpleName());

        // 需要存取者，當前這個就是一個具體的存取者，當然：也可以根據情況來弄
        name.accept(this);
    }
}

4、物件結構：維護元素、提供存取者存取所有元素的方法

原有類Person類中要進行不同且不相關操作的屬性被抽象化為了：抽象元素(接收存取者存取)+具體操作(該元素進行的不同且不相關的操作)
存取每個具體元素的也有了：抽象存取者+具體存取者
那現在還得有一個東西將元素+存取者進行連線，即：物件結構(新增元素+讓存取者能存取所有的元素)

package com.zixieqing.o1derive;

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

/**
 * <p>@description  : 該類功能  物件結構
 *                      1、新增元素 / 維護元素
 *                      2、讓存取者能存取所有元素
 * </p>
 * <p>@package      : com.zixieqing.o1derive</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class SubjectStructure {

    private List<People> peoples = new ArrayList<>();

    /**
     * 新增元素
     * @param people 要新增的元素
     * @return true/false
     */
    public boolean addElement(People people) {
        return peoples.add(people);
    }

    /**
     * 讓存取者能夠存取所有元素
     * @param visitor 存取者
     */
    public void getPeoples(Visitor visitor) {
        for (People people : peoples) {
            people.accept(visitor);
        }
    }
}

5、現在我們要新增元素、獲取元素就找"物件結構"+存取者

package com.zixieqing;

import com.zixieqing.o1derive.SubjectStructure;
import com.zixieqing.o1derive.impl.ConcreteVisitor;
import com.zixieqing.o1derive.impl.Name;

/**
 * <p>@description  : 該類功能  測試
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ApiTest {

    public static void main(String[] args) {
        SubjectStructure subjectStructure = new SubjectStructure();
        // 新增要存取的元素
        subjectStructure.addElement(new Name());
        // 通過物件結構+具體存取者進行元素存取
        subjectStructure.getPeoples(new ConcreteVisitor());
    }
}

因此：現在這個模式的邏輯草圖就出來了

3.2.10.2、簡單邏輯

場景：同一問題不同角度觀察，校長對於學生、老師的關注點(升學率)；家長對學生老師的關注點(成績)

1、抽象元素：接收存取者存取

package com.zixieqing.o2simple.user;

import com.zixieqing.o2simple.visitor.Visitor;

/**
 * <p>@description  : 該類功能  抽象元素：使用者資訊
 *                      1、接收存取者存取
 * </p>
 * <p>@package      : com.zixieqing.o2simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public abstract class User {

    /**
     * 姓名
     */
    public String name;
    /**
     * 身份；重點班、普通班 | 特級教師、普通教師、實習教師
     */
    public String identity;
    /**
     * 班級
     */
    public String clazz;

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

    /**
     * 核心存取方法
     * @param visitor 存取者
     */
    public abstract void accept(Visitor visitor);


}

具體元素：學生

package com.zixieqing.o2simple.user.impl;

import com.zixieqing.o2simple.user.User;
import com.zixieqing.o2simple.visitor.Visitor;

/**
 * <p>@description  : 該類功能  具體元素：學生
 * </p>
 * <p>@package      : com.zixieqing.o2simple.user.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Student extends User {

    public Student(String name, String identity, String clazz) {
        super(name, identity, clazz);
    }

    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    /**
     * 對這個元素進行的不同且不相關操作之一：排名
     * @return int 排名
     */
    public int ranking() {
        return (int) (Math.random() * 100);
    }
}

具體元素：老師

package com.zixieqing.o2simple.user.impl;

import com.zixieqing.o2simple.user.User;
import com.zixieqing.o2simple.visitor.Visitor;

import java.math.BigDecimal;

/**
 * <p>@description  : 該類功能  具體元素：老師
 * </p>
 * <p>@package      : com.zixieqing.o2simple.user.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Teacher extends User {
    public Teacher(String name, String identity, String clazz) {
        super(name, identity, clazz);
    }

    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }


    /**
     * 對這個具體元素進行的不同且不相關的操作之一：升本率
     * @return double 升學率
     */
    public double entranceRatio() {
        return BigDecimal.valueOf(Math.random() * 100).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    }
}

2、存取者：存取每個具體元素

package com.zixieqing.o2simple.visitor;

import com.zixieqing.o2simple.user.impl.*;

/**
 * <p>@description  : 該類功能  存取者：存取每個具體元素
 * </p>
 * <p>@package      : com.zixieqing.o2simple.visitor</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public interface Visitor {
    /**
     * 存取學生資訊
     * @param student 具體元素：學生
     */
    void visit(Student student);

    /**
     * 存取老師資訊
     * @param teacher 具體元素：老師
     */
    void visit(Teacher teacher);

}

具體存取者：校長

package com.zixieqing.o2simple.visitor.impl;

import com.zixieqing.o2simple.visitor.Visitor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.zixieqing.o2simple.user.impl.*;

/**
 * <p>@description  : 該類功能  具體存取者：校長
 * </p>
 * <p>@package      : com.zixieqing.o2simple.visitor.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Principal implements Visitor {

    private Logger logger = LoggerFactory.getLogger(Principal.class);

    public void visit(Student student) {
        logger.info("學生資訊 姓名：{} 班級：{}", student.name, student.clazz);
    }

    public void visit(Teacher teacher) {
        logger.info("學生資訊 姓名：{} 班級：{} 升學率：{}", teacher.name, teacher.clazz, teacher.entranceRatio());
    }
}

具體存取者：家長

package com.zixieqing.o2simple.visitor.impl;

import com.zixieqing.o2simple.visitor.Visitor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.zixieqing.o2simple.user.impl.*;

/**
 * <p>@description  : 該類功能  具體存取者：家長
 * </p>
 * <p>@package      : com.zixieqing.o2simple.visitor.impl</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class Parent implements Visitor {
    private Logger logger = LoggerFactory.getLogger(Parent.class);

    public void visit(Student student) {
        logger.info("學生資訊 姓名：{} 班級：{} 排名：{}", student.name, student.clazz, student.ranking());
    }

    public void visit(Teacher teacher) {
        logger.info("老師資訊 姓名：{} 班級：{} 級別：{}", teacher.name, teacher.clazz, teacher.identity);
    }
}

3、物件結構/資料看板

package com.zixieqing.o2simple;

import com.zixieqing.o2simple.user.User;
import com.zixieqing.o2simple.user.impl.Student;
import com.zixieqing.o2simple.user.impl.Teacher;
import com.zixieqing.o2simple.visitor.Visitor;

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

/**
 * <p>@description  : 該類功能  物件結構/資料看板
 *                      1、新增元素
 *                      2、存取所有元素
 * </p>
 * <p>@package      : com.zixieqing.o2simple</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class DataView {
    private List<User> userList = new ArrayList<User>();

    public DataView() {
        userList.add(new Student("謝飛機", "重點班", "一年一班"));
        userList.add(new Student("windy", "重點班", "一年一班"));
        userList.add(new Student("大毛", "普通班", "二年三班"));
        userList.add(new Student("Shing", "普通班", "三年四班"));
        userList.add(new Teacher("BK", "特級教師", "一年一班"));
        userList.add(new Teacher("娜娜Goddess", "特級教師", "一年一班"));
        userList.add(new Teacher("dangdang", "普通教師", "二年三班"));
        userList.add(new Teacher("澤東", "實習教師", "三年四班"));
    }

    /**
     * 獲取所有元素
     * @param visitor 存取者
     */
    public void show(Visitor visitor) {
        for (User user : userList) {
            user.accept(visitor);
        }
    }
}

4、測試

package com.zixieqing;

import com.zixieqing.o2simple.DataView;
import com.zixieqing.o2simple.visitor.impl.Parent;
import com.zixieqing.o2simple.visitor.impl.Principal;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>@description  : 該類功能  測試
 * </p>
 * <p>@package      : com.zixieqing</p>
 * <p>@author       : ZiXieqing</p>
 * <p>@version      : V1.0.0</p>
 */

public class ApiTest {

    public static void main(String[] args) {
        Logger logger = LoggerFactory.getLogger(ApiTest.class);

        DataView dataView = new DataView();

        logger.info("\r\n家長視角存取：");
        // 家長
        dataView.show(new Parent());

        logger.info("\r\n校長視角存取：");
        // 校長
        dataView.show(new Principal());
    }
}

結果

10:53:55.565 [main] INFO  com.zixieqing.ApiTest - 
家長視角存取：
10:53:55.568 [main] INFO  c.z.o2simple.visitor.impl.Parent - 學生資訊 姓名：謝飛機 班級：一年一班 排名：54
10:53:55.568 [main] INFO  c.z.o2simple.visitor.impl.Parent - 學生資訊 姓名：windy 班級：一年一班 排名：83
10:53:55.568 [main] INFO  c.z.o2simple.visitor.impl.Parent - 學生資訊 姓名：大毛 班級：二年三班 排名：84
10:53:55.568 [main] INFO  c.z.o2simple.visitor.impl.Parent - 學生資訊 姓名：Shing 班級：三年四班 排名：91
10:53:55.568 [main] INFO  c.z.o2simple.visitor.impl.Parent - 老師資訊 姓名：BK 班級：一年一班 級別：特級教師
10:53:55.568 [main] INFO  c.z.o2simple.visitor.impl.Parent - 老師資訊 姓名：娜娜Goddess 班級：一年一班 級別：特級教師
10:53:55.568 [main] INFO  c.z.o2simple.visitor.impl.Parent - 老師資訊 姓名：dangdang 班級：二年三班 級別：普通教師
10:53:55.568 [main] INFO  c.z.o2simple.visitor.impl.Parent - 老師資訊 姓名：澤東 班級：三年四班 級別：實習教師
10:53:55.568 [main] INFO  com.zixieqing.ApiTest - 
校長視角存取：
10:53:55.569 [main] INFO  c.z.o2simple.visitor.impl.Principal - 學生資訊 姓名：謝飛機 班級：一年一班
10:53:55.569 [main] INFO  c.z.o2simple.visitor.impl.Principal - 學生資訊 姓名：windy 班級：一年一班
10:53:55.569 [main] INFO  c.z.o2simple.visitor.impl.Principal - 學生資訊 姓名：大毛 班級：二年三班
10:53:55.569 [main] INFO  c.z.o2simple.visitor.impl.Principal - 學生資訊 姓名：Shing 班級：三年四班
10:53:55.571 [main] INFO  c.z.o2simple.visitor.impl.Principal - 學生資訊 姓名：BK 班級：一年一班 升學率：44.54
10:53:55.571 [main] INFO  c.z.o2simple.visitor.impl.Principal - 學生資訊 姓名：娜娜Goddess 班級：一年一班 升學率：45.49
10:53:55.571 [main] INFO  c.z.o2simple.visitor.impl.Principal - 學生資訊 姓名：dangdang 班級：二年三班 升學率：70.92
10:53:55.571 [main] INFO  c.z.o2simple.visitor.impl.Principal - 學生資訊 姓名：澤東 班級：三年四班 升學率：78.14

3.2.10.3、分析存取者模式

存取者模式的優點：

符合單一職責
擁有良好的擴充套件性，要擴充套件只需新增相應的元素+存取者即可

存取者模式的缺點：

因為元素類中有存取者的參照，即：元素的細節對存取者是公開的，這違反了迪米特法則(最少知道原則)
在存取者中用的是具體元素的參照，而不是抽象元素的參照，所以：這違反了里氏替換原則(即：多型)

存取者模式的重點：元素+存取者

(Java)設計模式：行為型

前言

3.2、行為型

* 3.2.1、責任鏈模式

3.2.1.1、簡單邏輯

* 3.2.2、命令模式

3.2.2.1、簡單邏輯

* 3.2.3、迭代器模式

3.2.3.1、簡單邏輯

* 3.2.4、中介者模式

3.2.4.1、簡單邏輯

3.2.5、備忘錄模式

3.4.5.1、簡單邏輯

* 3.2.6、觀察者模式

3.2.6.1、簡單邏輯

3.2.6.2、分析觀察者模式

* 3.2.7、狀態模式

3.2.7.1、簡單邏輯

3.2.7.2、分析狀態模式

3.2.7.3、狀態模式 VS 命令模式

* 3.2.8、策略模式

3.2.8.1、簡單邏輯

3.2.8.2、分析策略模式

3.2.8.3、策略模式 VS 狀態模式 VS 命令模式

3.2.8.3.1、策略模式 VS 狀態模式

3.2.8.3.2、策略模式 VS 命令模式

* 3.2.9、模板模式

3.2.9.1、簡單邏輯

3.2.9.2、分析模板方法模式

3.2.10、存取者模式

3.2.10.1、存取者模式是怎麼變出來的

3.2.10.2、簡單邏輯

3.2.10.3、分析存取者模式