摘要：創(chuàng)建型設(shè)計(jì)模式結(jié)構(gòu)型設(shè)計(jì)模式行為型設(shè)計(jì)模式行為型設(shè)計(jì)模式簡(jiǎn)而言之行為型設(shè)計(jì)模式關(guān)心的是對(duì)象之間的責(zé)任分配。這種模式被認(rèn)為是一種行為模式，因?yàn)樗梢愿淖兂绦虻倪\(yùn)行行為。

1.創(chuàng)建型設(shè)計(jì)模式
2.結(jié)構(gòu)型設(shè)計(jì)模式
3.行為型設(shè)計(jì)模式

簡(jiǎn)而言之

行為型設(shè)計(jì)模式關(guān)心的是對(duì)象之間的責(zé)任分配。它們與結(jié)構(gòu)模式的不同之處在于，它們不僅指定了結(jié)構(gòu)，而且還概述了它們之間消息傳遞/通信的模式。換句話(huà)說(shuō)，他們幫助回答“在軟件組件中如何管理一個(gè)行為?”

維基百科說(shuō)

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

顯示舉例

例如，在你的賬戶(hù)中有三種支付方式(A,B,C),每一個(gè)都有不同的金額的錢(qián)。A中有100美元，B中有300美元，C中有1000美元。選擇支付方式的偏好為A,B和C.你嘗試購(gòu)買(mǎi)價(jià)值210美元的商品。使用職責(zé)鏈，首先檢查A能否支持購(gòu)買(mǎi)，如果可以則進(jìn)行購(gòu)買(mǎi)，職責(zé)終端。否則，請(qǐng)求轉(zhuǎn)發(fā)到賬戶(hù)B,如果職責(zé)中斷，則請(qǐng)求一致轉(zhuǎn)發(fā)直到找到符合條件的處理器。在這里，A,B,C是鏈?zhǔn)竭B接，整個(gè)現(xiàn)象就是職責(zé)鏈。

簡(jiǎn)而言之

職責(zé)鏈模式幫助構(gòu)建一個(gè)對(duì)象鏈。請(qǐng)求從一個(gè)端點(diǎn)進(jìn)入，一直從一個(gè)對(duì)象到另一個(gè)對(duì)象，直到找到合適的處理器。

維基百科說(shuō)

在面向?qū)ο蟮脑O(shè)計(jì)中，責(zé)任鏈模式是由一個(gè)命令對(duì)象的源和一系列處理對(duì)象組成的設(shè)計(jì)模式。 每個(gè)處理對(duì)象都包含定義它可以處理的命令對(duì)象類(lèi)型的邏輯;其余的被傳遞給鏈中的下一個(gè)處理對(duì)象。

編程示例

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

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);
    }
}

現(xiàn)在我們使用上邊準(zhǔn)備的鏈?zhǔn)竭B接。

// 我們準(zhǔn)備的支付鏈如下
//      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);

現(xiàn)實(shí)舉例

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

維基百科說(shuō)

在面向?qū)ο蟮木幊讨?，命令模式是一種行為設(shè)計(jì)模式，在該模式中，對(duì)象被用來(lái)封裝執(zhí)行某個(gè)動(dòng)作所需的所有信息，或者在稍后的時(shí)間觸發(fā)事件。該信息包括方法名稱(chēng)、擁有方法參數(shù)的對(duì)象以及方法參數(shù)的值。

編程示例

首先，我們有一個(gè)接收器，它可以執(zhí)行所有可以執(zhí)行的動(dòng)作。

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

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

然后我們有一個(gè)接口，每個(gè)命令都要實(shí)現(xiàn)，另外我們有一組命令。

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();
    }
}

接著我們有調(diào)用者(Invoker)，客戶(hù)端可以使用調(diào)用者來(lái)處理任意的命令

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

最后看一下客戶(hù)端如何使用

Bulb bulb = new Bulb();

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

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

remoteControl.submit(turnOnCommand);

命令模式還可以用于實(shí)現(xiàn)基于事務(wù)的系統(tǒng)。當(dāng)您執(zhí)行命令的歷史時(shí)，您將保持它的歷史。如果最終的命令被成功執(zhí)行，那么所有的好方法都只是遍歷歷史，并在所有執(zhí)行的命令上執(zhí)行“撤消”。

現(xiàn)實(shí)舉例

一臺(tái)舊的收音機(jī)將會(huì)是一個(gè)很好的迭代器的例子，用戶(hù)可以從某個(gè)頻道開(kāi)始，然后使用下一個(gè)或之前的按鈕來(lái)瀏覽各個(gè)頻道。 或者舉一個(gè)MP3播放器或電視機(jī)的例子，你可以按下一個(gè)和之前的按鈕，通過(guò)連續(xù)的頻道。換句話(huà)說(shuō)，它們都提供一個(gè)接口，通過(guò)各自的頻道、歌曲或廣播電臺(tái)進(jìn)行迭代。

簡(jiǎn)而言之

它提供了一種方法來(lái)訪(fǎng)問(wèn)對(duì)象的元素，而不暴露底層的表示。

維基百科說(shuō)

在面向?qū)ο缶幊讨?，迭代器模式是一種設(shè)計(jì)模式，其中迭代器用于遍歷容器并訪(fǎng)問(wèn)容器的元素。 迭代器模式將算法從容器中分離出來(lái);在某些情況下，算法必須是特定于容器的，因此不能解耦。

編程舉例

在Java中可以結(jié)合Iterator接口來(lái)實(shí)現(xiàn)迭代器模式。翻譯上邊收音機(jī)的例子如下；

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());
}

現(xiàn)實(shí)舉例

一個(gè)普通的例子是當(dāng)你和某人在你的移動(dòng)電話(huà)上交談時(shí)，你和他們之間有一個(gè)網(wǎng)絡(luò)供應(yīng)商，你的談話(huà)通過(guò)它而不是直接發(fā)送。在這種情況下，網(wǎng)絡(luò)供應(yīng)商是中介。

簡(jiǎn)而言之

中介模式添加第三方對(duì)象(稱(chēng)為中介)來(lái)控制兩個(gè)對(duì)象之間的交互(稱(chēng)為同事)。它有助于減少相互通信的類(lèi)之間的耦合。因?yàn)楝F(xiàn)在他們不需要知道彼此的實(shí)現(xiàn)。

維基百科說(shuō)

在軟件工程中，中介模式定義了一個(gè)對(duì)象，它封裝了一組對(duì)象如何交互。這種模式被認(rèn)為是一種行為模式，因?yàn)樗梢愿淖兂绦虻倪\(yùn)行行為。

編程示例

這里是一個(gè)與用戶(hù)相互發(fā)送消息的聊天室最簡(jiǎn)單的例子。

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

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));
    }
}

下面是我們的用戶(hù)

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!");

現(xiàn)實(shí)舉例

以計(jì)算器為例，當(dāng)您執(zhí)行某些計(jì)算時(shí)，最后的計(jì)算將保存在內(nèi)存中，這樣您就可以返回到它，并使用一些操作按鈕(即管理員)恢復(fù)它。

簡(jiǎn)而言之

Memento模式是關(guān)于捕獲和存儲(chǔ)對(duì)象的當(dāng)前狀態(tài)的方式，它可以在稍后以一種平滑的方式恢復(fù)。

維基百科說(shuō)

memento模式是一種軟件設(shè)計(jì)模式，它提供了將對(duì)象恢復(fù)到以前狀態(tài)的能力(通過(guò)回滾撤銷(xiāo))。

通常在需要提供某種撤銷(xiāo)功能時(shí)非常有用。

編程示例

讓我們舉一個(gè)文本編輯器的例子，它可以隨時(shí)保存狀態(tài)，如果需要，可以恢復(fù)。

首先，我們有一個(gè)可以保存編輯器狀態(tài)的memento對(duì)象。

public class EditorMemento {
    private String content;

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

    public String getContent() {
        return content;
    }
}

界限來(lái)我們有一個(gè)編輯器來(lái)使用memento對(duì)象

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());

現(xiàn)實(shí)舉例

一個(gè)很好的例子就是求職者在招聘網(wǎng)站時(shí)，只要有匹配的工作機(jī)會(huì)，他們就會(huì)得到通知。

簡(jiǎn)而言之

定義對(duì)象之間的依賴(lài)關(guān)系，以便每當(dāng)對(duì)象更改其狀態(tài)時(shí)，都會(huì)通知所有依賴(lài)對(duì)象。

維基百科說(shuō)

觀(guān)察者模式是一種軟件設(shè)計(jì)模式，其中一個(gè)對(duì)象被稱(chēng)為主題，它維護(hù)一個(gè)被稱(chēng)為觀(guān)察者的依賴(lài)項(xiàng)列表，并通過(guò)調(diào)用其中一個(gè)方法來(lái)自動(dòng)通知它們?nèi)魏螤顟B(tài)變化。

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

注:JDK中提供了Observer接口和Observal抽象類(lèi)來(lái)實(shí)現(xiàn)觀(guān)察者模式

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()));
    }
}

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

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"));

現(xiàn)實(shí)舉例

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

簡(jiǎn)而言之

訪(fǎng)問(wèn)者模式允許您在不修改對(duì)象的情況下為對(duì)象添加更多操作。

維基百科說(shuō)

在面向?qū)ο缶幊毯蛙浖こ讨?，訪(fǎng)問(wèn)者設(shè)計(jì)模式是一種將算法從其操作的對(duì)象結(jié)構(gòu)中分離出來(lái)的方法。這種分離的實(shí)際結(jié)果是，在不修改這些結(jié)構(gòu)的情況下，可以向現(xiàn)有的對(duì)象結(jié)構(gòu)添加新的操作。這是遵循開(kāi)放/封閉原則的一種方法。

編程示例

讓我們舉一個(gè)動(dòng)物園模擬的例子，我們有幾種不同種類(lèi)的動(dòng)物，我們必須讓它們發(fā)聲。 我們使用訪(fǎng)問(wèn)者模式來(lái)翻譯一下這個(gè)例子。

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

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

動(dòng)物的實(shí)現(xiàn)

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);
    }
}

訪(fǎng)問(wèn)者

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);

我們本可以簡(jiǎn)單地為動(dòng)物建立一個(gè)繼承等級(jí)，但如果我們需要向動(dòng)物添加新動(dòng)作，我們就必須修改動(dòng)物。但現(xiàn)在我們不需要改變它們。例如，假設(shè)我們被要求將跳轉(zhuǎn)行為添加到動(dòng)物中，我們可以簡(jiǎn)單地通過(guò)創(chuàng)建一個(gè)新的訪(fǎng)問(wèn)者來(lái)添加該行為。

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);

現(xiàn)實(shí)舉例

考慮一下排序的例子，我們實(shí)現(xiàn)了冒泡排序，但數(shù)據(jù)開(kāi)始增長(zhǎng)，而冒泡排序開(kāi)始變得非常緩慢。為了解決這個(gè)問(wèn)題，我們實(shí)現(xiàn)了快速排序。但是現(xiàn)在，盡管快速排序算法在大型數(shù)據(jù)集上做得更好，但是對(duì)于較小的數(shù)據(jù)集來(lái)說(shuō)，它是非常慢的。為了處理這個(gè)問(wèn)題，我們實(shí)現(xiàn)了一個(gè)策略，在這個(gè)策略中，小數(shù)據(jù)集，冒泡排序?qū)⒈皇褂?，并用于更大的，快速排序?/pre>
簡(jiǎn)而言之
策略模式允許您根據(jù)情況切換算法或策略。策略模式允許您根據(jù)情況切換算法或策略。
維基百科說(shuō)
在計(jì)算機(jī)編程中，策略模式(也稱(chēng)為策略模式)是一種行為軟件設(shè)計(jì)模式，它允許在運(yùn)行時(shí)選擇算法的行為。
編程示例
翻譯我們上面的例子。首先，我們有策略接口和不同的策略實(shí)現(xiàn)。
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;
    }
}
我們的客戶(hù)端可以使用任何策略。
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);
? 狀態(tài)模式
現(xiàn)實(shí)舉例
假設(shè)您正在使用一些繪圖應(yīng)用程序，您選擇畫(huà)筆繪制?，F(xiàn)在畫(huà)筆會(huì)根據(jù)所選的顏色改變它的行為如果你選擇了紅色，它會(huì)畫(huà)出紅色，如果藍(lán)色，它會(huì)是藍(lán)色的等等。
簡(jiǎn)而言之
它允許在狀態(tài)更改時(shí)更改類(lèi)的行為。
維基百科說(shuō)
狀態(tài)模式是一種行為軟件設(shè)計(jì)模式，它以面向?qū)ο蟮姆绞綄?shí)現(xiàn)狀態(tài)機(jī)。 在狀態(tài)模式下，狀態(tài)機(jī)通過(guò)實(shí)現(xiàn)每個(gè)單個(gè)狀態(tài)作為狀態(tài)模式接口的派生類(lèi)實(shí)現(xiàn)，并通過(guò)調(diào)用模式父類(lèi)定義的方法實(shí)現(xiàn)狀態(tài)轉(zhuǎn)換。
狀態(tài)模式可以解釋為一種策略模式，它可以通過(guò)在模式接口中定義的方法調(diào)用來(lái)切換當(dāng)前策略。
編程示例
讓我們舉一個(gè)文本編輯器的例子，它允許你改變輸入的文本的狀態(tài)，如果你選擇了粗體，它開(kāi)始以粗體輸入；如果選擇斜體，以斜體輸入，等等。
首先我們有狀態(tài)接口和狀態(tài)的實(shí)現(xiàn)。
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);
    }
}
然后我們有一個(gè)編輯器
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");
? 模版方法模式
現(xiàn)實(shí)舉例
假設(shè)我們要建一些房子。建造的步驟可能是這樣的。

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

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

簡(jiǎn)而言之
模板方法定義了如何執(zhí)行某個(gè)算法的骨架，但將這些步驟的實(shí)現(xiàn)轉(zhuǎn)移到子類(lèi)中。
維基百科說(shuō)
在軟件工程中，模板方法模式是一種行為設(shè)計(jì)模式，它在操作中定義算法的程序骨架，將一些步驟推遲到子類(lèi)。它讓一個(gè)人重新定義算法的某些步驟而不改變算法的結(jié)構(gòu)。
Programmatic Example
假設(shè)我們有一個(gè)構(gòu)建工具，它可以幫助我們測(cè)試、lint、構(gòu)建、生成構(gòu)建報(bào)告(比如代碼覆蓋率報(bào)告、linting報(bào)告等)，并在測(cè)試服務(wù)器上部署我們的應(yīng)用程序。
首先，我們有一個(gè)為構(gòu)建算法指定骨架的基類(lèi)。
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();
}
實(shí)現(xiàn)
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();