摘要：創建型設計模式結構型設計模式行為型設計模式行為型設計模式簡而言之行為型設計模式關心的是對象之間的責任分配。這種模式被認為是一種行為模式，因為它可以改變程序的運行行為。

1.創建型設計模式
2.結構型設計模式
3.行為型設計模式

簡而言之

行為型設計模式關心的是對象之間的責任分配。它們與結構模式的不同之處在于，它們不僅指定了結構，而且還概述了它們之間消息傳遞/通信的模式。換句話說，他們幫助回答“在軟件組件中如何管理一個行為?”

維基百科說

在軟件工程中，行為設計模式是一種設計模式，用于識別對象之間的公共通信模式并實現這些模式. 這樣做，這些設計模式在傳遞信息的時候增加了靈活性。

顯示舉例

例如，在你的賬戶中有三種支付方式(A,B,C),每一個都有不同的金額的錢。A中有100美元，B中有300美元，C中有1000美元。選擇支付方式的偏好為A,B和C.你嘗試購買價值210美元的商品。使用職責鏈，首先檢查A能否支持購買，如果可以則進行購買，職責終端。否則，請求轉發到賬戶B,如果職責中斷，則請求一致轉發直到找到符合條件的處理器。在這里，A,B,C是鏈式連接，整個現象就是職責鏈。

簡而言之

職責鏈模式幫助構建一個對象鏈。請求從一個端點進入，一直從一個對象到另一個對象，直到找到合適的處理器。

維基百科說

在面向對象的設計中，責任鏈模式是由一個命令對象的源和一系列處理對象組成的設計模式。 每個處理對象都包含定義它可以處理的命令對象類型的邏輯;其余的被傳遞給鏈中的下一個處理對象。

編程示例

翻譯我們上面的帳戶示例。首先，我們有一個基本帳戶，它有把帳戶合并在一起的邏輯，和一些其他帳戶。

public abstract class Account {
    protected float balance;
    private Account successor;

    public Account(float balance) {
        this.balance = balance;
    }

    public void setNext(Account account)
    {
        this.successor = account;
    }

    public void pay(float amount)
    {
        if(canPay(amount))
        {
            System.out.println(String.format("Can pay $%s use %s",amount,this.getClass().getSimpleName()));
        }
        else
        {
            System.out.println(String.format("Can not pay,forwarding:%s",successor.getClass().getSimpleName()));
            successor.pay(amount);
        }
    }

    public boolean canPay(float amount)
    {
        return Float.compare(balance,amount) > 0;
    }
}

public class Bank extends Account {
    public Bank(float balance) {
        super(balance);
    }
}

public class Paypal extends Account {
    public Paypal(float balance) {
        super(balance);
    }
}

public class Bitcoin extends Account{
    public Bitcoin(float balance) {
        super(balance);
    }
}

現在我們使用上邊準備的鏈式連接。

// 我們準備的支付鏈如下
//      bank->paypal->bitcoin
//
// 首選bank
//  如果 bank不能支付選擇 paypal
//  如果 paypal不能支付選擇 bit coin

Account bank = new Bank(100);
Account paypay = new Paypal(200);
Account bitcon = new Bitcoin(300);

bank.setNext(paypay);
paypay.setNext(bitcon);

bank.pay(259);

現實舉例

一個典型的例子就是你在餐館點餐。你(“客戶端”)問服務員(調用者，“Invoker”)帶一些食物（“命令”,Command)，服務員簡單地將請求轉發給廚師，這個廚師是懂得如何烹飪的人。
另一個例子是你(客戶端，"Client")使用遙控(調用者,"Invoke")切換電視節目(命令,"Command")。
簡而言之
允許您封裝對象中的操作。此模式背后的關鍵思想是提供將客戶端與接收方解耦合的方法。

維基百科說

在面向對象的編程中，命令模式是一種行為設計模式，在該模式中，對象被用來封裝執行某個動作所需的所有信息，或者在稍后的時間觸發事件。該信息包括方法名稱、擁有方法參數的對象以及方法參數的值。

編程示例

首先，我們有一個接收器，它可以執行所有可以執行的動作。

// Receiver(接收者)
public class Bulb {
    public void turnOn()
    {
        System.out.println("Bulb has been lit");
    }

    public void turnOff()
    {
        System.out.println("Darkness");
    }
}

然后我們有一個接口，每個命令都要實現，另外我們有一組命令。

public interface Command {
    void undo();
    void redo();
    void execute();
}

// Command
public class TurnOffCommand implements Command {
    private Bulb bulb;

    public TurnOffCommand(Bulb bulb) {
        this.bulb = bulb;
    }

    @Override
    public void undo() {
     this.bulb.turnOn();
    }

    @Override
    public void redo() {
        this.bulb.turnOff();
    }

    @Override
    public void execute() {
        this.bulb.turnOff();
    }
}

public class TurnOnCommand implements Command {
    private Bulb bulb;

    public TurnOnCommand(Bulb bulb) {
        this.bulb = bulb;
    }

    @Override
    public void undo() {
        this.bulb.turnOff();
    }

    @Override
    public void redo() {
        this.bulb.turnOn();
    }

    @Override
    public void execute() {
        this.bulb.turnOn();
    }
}

接著我們有調用者(Invoker)，客戶端可以使用調用者來處理任意的命令

// 調用者
public class RemoteControl {
    public void submit(Command command)
    {
        command.execute();
    }
}

最后看一下客戶端如何使用

Bulb bulb = new Bulb();

Command turnOnCommand = new TurnOnCommand(bulb);
Command turnOffCommand = new TurnOffCommand(bulb);

RemoteControl remoteControl = new RemoteControl();
remoteControl.submit(turnOnCommand);

remoteControl.submit(turnOnCommand);

命令模式還可以用于實現基于事務的系統。當您執行命令的歷史時，您將保持它的歷史。如果最終的命令被成功執行，那么所有的好方法都只是遍歷歷史，并在所有執行的命令上執行“撤消”。

現實舉例

一臺舊的收音機將會是一個很好的迭代器的例子，用戶可以從某個頻道開始，然后使用下一個或之前的按鈕來瀏覽各個頻道。 或者舉一個MP3播放器或電視機的例子，你可以按下一個和之前的按鈕，通過連續的頻道。換句話說，它們都提供一個接口，通過各自的頻道、歌曲或廣播電臺進行迭代。

簡而言之

它提供了一種方法來訪問對象的元素，而不暴露底層的表示。

維基百科說

在面向對象編程中，迭代器模式是一種設計模式，其中迭代器用于遍歷容器并訪問容器的元素。 迭代器模式將算法從容器中分離出來;在某些情況下，算法必須是特定于容器的，因此不能解耦。

編程舉例

在Java中可以結合Iterator接口來實現迭代器模式。翻譯上邊收音機的例子如下；

public class RadioStation {
    private float frequency;

    public RadioStation(float frequency) {
        this.frequency = frequency;
    }

    public float getFrequency() {
        return frequency;
    }
}

我們有我們自己的迭代器

public class StationList implements Iterator {

    private List stations = new ArrayList<>();
    private int counter = 0;

    @Override
    public boolean hasNext() {
        return counter < stations.size();
    }

    @Override
    public RadioStation next() {
        return stations.get(counter++);
    }

    public void add(RadioStation radioStation)
    {
        stations.add(radioStation);
    }

    public RadioStation remove(RadioStation radioStation)
    {
        for(int i = 0; i < stations.size(); i++)
        {
            if(Float.compare(stations.get(i).getFrequency(),radioStation.getFrequency())==0)
            {
                return  stations.remove(i);
            }
        }

        return null;
    }

    public int count()
    {
        return stations.size();
    }

    public RadioStation current()
    {
        return stations.get(counter);
    }

    public int key()
    {
        return counter;
    }

    public void rewind()
    {
        counter=0;
    }

}

使用方式如下

StationList stationList = new StationList();
stationList.add(new RadioStation(120.1F));
stationList.add(new RadioStation(99.1F));
stationList.add(new RadioStation(156.7F));
stationList.add(new RadioStation(138.2F));
stationList.add(new RadioStation(89.6F));
stationList.add(new RadioStation(78.9F));

while(stationList.hasNext())
{
    System.out.println(stationList.next().getFrequency());
}

現實舉例

一個普通的例子是當你和某人在你的移動電話上交談時，你和他們之間有一個網絡供應商，你的談話通過它而不是直接發送。在這種情況下，網絡供應商是中介。

簡而言之

中介模式添加第三方對象(稱為中介)來控制兩個對象之間的交互(稱為同事)。它有助于減少相互通信的類之間的耦合。因為現在他們不需要知道彼此的實現。

維基百科說

在軟件工程中，中介模式定義了一個對象，它封裝了一組對象如何交互。這種模式被認為是一種行為模式，因為它可以改變程序的運行行為。

編程示例

這里是一個與用戶相互發送消息的聊天室最簡單的例子。

首先我們有中介，也就是聊天室。

public interface ChatRoomMediator {
    void showMessage(User user,String message);
}

// Mediator
public class ChatRoom implements ChatRoomMediator {
    private SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    @Override
    public void showMessage(User user, String message) {
        String date = sf.format(Calendar.getInstance().getTime());
        System.out.println(String.format("%s [%s] says:%s",date,user.getUserName(),message));
    }
}

下面是我們的用戶

public class User {
    private String userName;
    private ChatRoomMediator chatRoomMediator;

    public User(String userName, ChatRoomMediator chatRoomMediator) {
        this.userName = userName;
        this.chatRoomMediator = chatRoomMediator;
    }

    public String getUserName() {
        return userName;
    }

    public void sendMessage(String message)
    {
        this.chatRoomMediator.showMessage(this,message);
    }
}

使用如下

ChatRoomMediator mediator = new ChatRoom();
User john = new User("John",mediator);
User jane = new User("Jane",mediator);

john.sendMessage("Hi there!");
jane.sendMessage("Hey!");

現實舉例

以計算器為例，當您執行某些計算時，最后的計算將保存在內存中，這樣您就可以返回到它，并使用一些操作按鈕(即管理員)恢復它。

簡而言之

Memento模式是關于捕獲和存儲對象的當前狀態的方式，它可以在稍后以一種平滑的方式恢復。

維基百科說

memento模式是一種軟件設計模式，它提供了將對象恢復到以前狀態的能力(通過回滾撤銷)。

通常在需要提供某種撤銷功能時非常有用。

編程示例

讓我們舉一個文本編輯器的例子，它可以隨時保存狀態，如果需要，可以恢復。

首先，我們有一個可以保存編輯器狀態的memento對象。

public class EditorMemento {
    private String content;

    public EditorMemento(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }
}

界限來我們有一個編輯器來使用memento對象

public class Editor {
    private String content="";

    public void type(String words)
    {
       content = String.format("%s %s",content,words);
    }

    public EditorMemento save()
    {
        return new EditorMemento(content);
    }

    public void resotre(EditorMemento memento)
    {
        this.content = memento.getContent();
    }

    public String getContent() {
        return content;
    }
}

使用方式如下

Editor editor = new Editor();
editor.type("This is the first sentence.");
editor.type("This is second.");

EditorMemento memento = editor.save();
editor.type("And this is third.");
editor.resotre(memento);

System.out.println(editor.getContent());

現實舉例

一個很好的例子就是求職者在招聘網站時，只要有匹配的工作機會，他們就會得到通知。

簡而言之

定義對象之間的依賴關系，以便每當對象更改其狀態時，都會通知所有依賴對象。

維基百科說

觀察者模式是一種軟件設計模式，其中一個對象被稱為主題，它維護一個被稱為觀察者的依賴項列表，并通過調用其中一個方法來自動通知它們任何狀態變化。

編程示例
翻譯我們上邊的例子。首先我們有需要被通知招聘職位的求職者。

注:JDK中提供了Observer接口和Observal抽象類來實現觀察者模式

public class JobPost {
    public String title;

    public JobPost(String title) {
        this.title = title;
    }

    public String getTitle() {
        return title;
    }
}

public class JobSeeker implements Observer {
    private String name;

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

    @Override
    public void update(Observable o, Object arg) {
        JobPost jobPost = (JobPost)arg;

        System.out.println(String.format("Hi,%s!New Job posted:%s",name,jobPost.getTitle()));
    }
}

然后，我們會有招聘人員會訂閱的招聘信息。

public class JobPostings extends java.util.Observable {

    private void notity(JobPost jobPost)
    {
        super.setChanged();
        notifyObservers(jobPost);
    }

    public void addJob(JobPost jobPost)
    {
        notity(jobPost);
    }
}

使用方式如下

JobSeeker john = new JobSeeker("John");
JobSeeker jane = new JobSeeker("Jane");

JobPostings jobPostings = new JobPostings();
jobPostings.addObserver(john);
jobPostings.addObserver(jane);

jobPostings.addJob(new JobPost("Java Developer"));

現實舉例

考慮某人去迪拜。 他們只是需要一種方式(即簽證)進入迪拜。抵達后，他們可以自行前往迪拜的任何地方，而無需事先征得許可或做一些跑腿的工作，以便參觀任何地方，只要讓他們知道一個地方，他們就可以去參觀。 訪問者模式允許你這樣做，它可以幫助你添加訪問的地方，這樣他們就可以盡可能多地訪問，而不必做任何跑腿的工作。

簡而言之

訪問者模式允許您在不修改對象的情況下為對象添加更多操作。

維基百科說

在面向對象編程和軟件工程中，訪問者設計模式是一種將算法從其操作的對象結構中分離出來的方法。這種分離的實際結果是，在不修改這些結構的情況下，可以向現有的對象結構添加新的操作。這是遵循開放/封閉原則的一種方法。

編程示例

讓我們舉一個動物園模擬的例子，我們有幾種不同種類的動物，我們必須讓它們發聲。 我們使用訪問者模式來翻譯一下這個例子。

// Visitee
public interface Animal {
    void accept(AnimalOperation operation);
}

// Visitor
public interface AnimalOperation {
    void visitMonkey(Monkey monkey);
    void visitLoin(Lion lion);
    void visitDolphin(Dolphin dolphin);
}

動物的實現

public class Monkey implements Animal {
    public void shout()
    {
        System.out.println("Ooh oo aa aa!");
    }

    @Override
    public void accept(AnimalOperation operation) {
        operation.visitMonkey(this);
    }
}

public class Dolphin implements Animal {
    public void speak()
    {
        System.out.println("Tuut tuttu tuutt!");
    }

    @Override
    public void accept(AnimalOperation operation) {
        operation.visitDolphin(this);
    }
}

public class Lion implements Animal {
    public void roar()
    {
        System.out.println("Roaaar");
    }

    @Override
    public void accept(AnimalOperation operation) {
        operation.visitLoin(this);
    }
}

訪問者

public class Speak implements AnimalOperation {
    @Override
    public void visitMonkey(Monkey monkey) {
        monkey.shout();
    }

    @Override
    public void visitLoin(Lion lion) {
        lion.roar();
    }

    @Override
    public void visitDolphin(Dolphin dolphin) {
        dolphin.speak();
    }
}

使用方式如下

Monkey monkey = new Monkey();
        Lion lion = new Lion();
        Dolphin dolphin = new Dolphin();

        Speak speak = new Speak();

        monkey.accept(speak);
        lion.accept(speak);
        dolphin.accept(speak);

我們本可以簡單地為動物建立一個繼承等級，但如果我們需要向動物添加新動作，我們就必須修改動物。但現在我們不需要改變它們。例如，假設我們被要求將跳轉行為添加到動物中，我們可以簡單地通過創建一個新的訪問者來添加該行為。

public class Jump implements AnimalOperation {
    @Override
    public void visitMonkey(Monkey monkey) {
        System.out.println("Jumped 20 feet high! on to the tree!");
    }

    @Override
    public void visitLoin(Lion lion) {
        System.out.println("Jumped 7 feet! Back on the ground!");
    }

    @Override
    public void visitDolphin(Dolphin dolphin) {
        System.out.println("Walked on water a little and disappeared");
    }
}

使用如下

Monkey monkey = new Monkey();
Lion lion = new Lion();
Dolphin dolphin = new Dolphin();

Speak speak = new Speak();

monkey.accept(speak);
lion.accept(speak);
dolphin.accept(speak);
System.out.println("=======================");

AnimalOperation jump = new Jump();
monkey.accept(jump);
lion.accept(jump);
dolphin.accept(jump);

現實舉例

考慮一下排序的例子，我們實現了冒泡排序，但數據開始增長，而冒泡排序開始變得非常緩慢。為了解決這個問題，我們實現了快速排序。但是現在，盡管快速排序算法在大型數據集上做得更好，但是對于較小的數據集來說，它是非常慢的。為了處理這個問題，我們實現了一個策略，在這個策略中，小數據集，冒泡排序將被使用，并用于更大的，快速排序。

簡而言之

策略模式允許您根據情況切換算法或策略。策略模式允許您根據情況切換算法或策略。

維基百科說

在計算機編程中，策略模式(也稱為策略模式)是一種行為軟件設計模式，它允許在運行時選擇算法的行為。

編程示例

翻譯我們上面的例子。首先，我們有策略接口和不同的策略實現。

public interface SortStrategy {
    int[] sort(int[] arr);
}

public class BubbleSortStrategy implements SortStrategy {
    @Override
    public int[] sort(int[] arr) {
        System.out.println("Sorting using bubble sort");

        return arr;
    }
}

public class QuickSortStrategy implements SortStrategy{
    @Override
    public int[] sort(int[] arr) {
        System.out.println("Sorting using quick sort");
        return arr;
    }
}

我們的客戶端可以使用任何策略。

public class Sorter {
    private SortStrategy sortStrategy;

    public Sorter(SortStrategy sortStrategy) {
        this.sortStrategy = sortStrategy;
    }

    public int[] sort(int[] arr)
    {
        return sortStrategy.sort(arr);
    }
}

使用方式如下

int[] arr = {1, 5, 4, 3, 2, 8};

Sorter sorter = new Sorter(new BubbleSortStrategy());
sorter.sort(arr);
System.out.println("=========================");
sorter = new Sorter(new QuickSortStrategy());
sorter.sort(arr);

現實舉例

假設您正在使用一些繪圖應用程序，您選擇畫筆繪制?，F在畫筆會根據所選的顏色改變它的行為如果你選擇了紅色，它會畫出紅色，如果藍色，它會是藍色的等等。

簡而言之

它允許在狀態更改時更改類的行為。

維基百科說

狀態模式是一種行為軟件設計模式，它以面向對象的方式實現狀態機。 在狀態模式下，狀態機通過實現每個單個狀態作為狀態模式接口的派生類實現，并通過調用模式父類定義的方法實現狀態轉換。
狀態模式可以解釋為一種策略模式，它可以通過在模式接口中定義的方法調用來切換當前策略。

編程示例

讓我們舉一個文本編輯器的例子，它允許你改變輸入的文本的狀態，如果你選擇了粗體，它開始以粗體輸入；如果選擇斜體，以斜體輸入，等等。

首先我們有狀態接口和狀態的實現。

public interface WriteState {
    void write(String word);
}

public class UpperState implements WriteState {
    @Override
    public void write(String word) {
        System.out.println(word.toUpperCase());
    }
}

public class LowerState implements WriteState {
    @Override
    public void write(String word) {
        System.out.println(word.toLowerCase());
    }
}

public class DefaultState implements WriteState {
    @Override
    public void write(String word) {
        System.out.println(word);
    }
}

然后我們有一個編輯器

public class TextEditor {
    private WriteState writeState;

    public TextEditor(WriteState writeState) {
        this.writeState = writeState;
    }

    public void setWriteState(WriteState writeState) {
        this.writeState = writeState;
    }

    public void type(String word)
    {
        this.writeState.write(word);
    }
}

使用方式如下

TextEditor editor = new TextEditor(new DefaultState());
editor.type("First line");

editor.setWriteState(new LowerState());
editor.type("Second line");
editor.type("Third line");

editor.setWriteState(new UpperState());
editor.type("Forth line");
editor.type("Fifth line");

現實舉例

假設我們要建一些房子。建造的步驟可能是這樣的。

打地基
建墻
增加房頂
增加其他的樓層

這些步驟的順序是不可能改變的，例如，在建造墻之前你不能建造屋頂，但是每一個步驟都可以被修改，例如墻壁可以用木頭或聚酯或石頭做。

簡而言之

模板方法定義了如何執行某個算法的骨架，但將這些步驟的實現轉移到子類中。

維基百科說

在軟件工程中，模板方法模式是一種行為設計模式，它在操作中定義算法的程序骨架，將一些步驟推遲到子類。它讓一個人重新定義算法的某些步驟而不改變算法的結構。

Programmatic Example

假設我們有一個構建工具，它可以幫助我們測試、lint、構建、生成構建報告(比如代碼覆蓋率報告、linting報告等)，并在測試服務器上部署我們的應用程序。

首先，我們有一個為構建算法指定骨架的基類。

public abstract class Builder {

    public void build() {
        test();
        lint();
        assemble();
        deploy();
    }

    public abstract void test();

    public abstract void lint();

    public abstract void assemble();

    public abstract void deploy();
}

實現

public class AndroidBuilder extends Builder {
    @Override
    public void test() {
        System.out.println("Running android tests");
    }

    @Override
    public void lint() {
        System.out.println("Linting the android code");
    }

    @Override
    public void assemble() {
        System.out.println("Assembling the android build");
    }

    @Override
    public void deploy() {
        System.out.println("Deploying android build to server");
    }
}

public class IOSBuilder extends Builder {
    @Override
    public void test() {
        System.out.println("Running ios tests");
    }

    @Override
    public void lint() {
        System.out.println("Linting the ios code");
    }

    @Override
    public void assemble() {
        System.out.println("Assembling the ios build");
    }

    @Override
    public void deploy() {
        System.out.println("Deploying ios build to server");
    }
}

使用如下

Builder builder = new AndroidBuilder();
builder.build();
System.out.println("========================");
builder = new IOSBuilder();
builder.build();