設計模式之狀態模式(State)摘錄

阿新 • • 發佈：2017-05-09

表示 facade test true efi 子類 ble 叠代系列

23種GOF設計模式一般分為三大類：創建型模式、結構型模式、行為模式。

創建型模式抽象了實例化過程，它們幫助一個系統獨立於怎樣創建、組合和表示它的那些對象。一個類創建型模式使用繼承改變被實例化的類，而一個對象創建型模式將實例化托付給還有一個對象。創建型模式有兩個不斷出現的主旋律。

第一，它們都將關於該系統使用哪些詳細的類的信息封裝起來。第二，它們隱藏了這些類的實例是怎樣被創建和放在一起的。整個系統關於這些對象所知道的是由抽象類所定義的接口。

因此。創建型模式在什麽被創建。誰創建它，它是怎樣被創建的。以及何時創建這些方面給予了非常大的靈活性。它們同意用結構和功能區別非常大的“產品”對象配置一個系統。配置能夠是靜態的(即在編譯時指定)，也能夠是動態的(在執行時)。

結構型模式涉及到怎樣組合類和對象以獲得更大的結構。

結構型類模式採用繼承機制來組合接口或實現。

結構型對象模式不是對接口和實現進行組合，而是描寫敘述了怎樣對一些對象進行組合，從而實現新功能的一些方法。由於能夠在執行時刻改變對象組合關系，所以對象組合方式具有更大的靈活性。而這樣的機制用靜態類組合是不可能實現的。

行為模式涉及到算法和對象間職責的分配。行為模式不僅描寫敘述對象或類的模式。還描寫敘述它們之間的通信模式。這些模式刻畫了在執行時難以跟蹤的復雜的控制流。它們將用戶的註意力從控制流轉移到對象間的聯系方式上來。行為類模式使用繼承機制在類間分派行為。

行為對象模式使用對象復合而不是繼承。

一些行為對象模式描寫敘述了一組對等的對象怎樣相互協作以完畢當中任一個對象都無法單獨完畢的任務。

創建型模式包含：1、FactoryMethod(工廠方法模式)；2、Abstract Factory(抽象工廠模式)；3、Singleton(單例模式)；4、Builder(建造者模式、生成器模式)。5、Prototype(原型模式).

結構型模式包含：6、Bridge(橋接模式)；7、Adapter(適配器模式)。8、Decorator(裝飾模式)；9、Composite(組合模式)。10、Flyweight(享元模式)；11、Facade(外觀模式)；12、Proxy(代理模式).

行為模式包含：13、TemplateMethod(模板方法模式)；14、Strategy(策略模式)。15、State(狀態模式)；16、Observer(觀察者模式)；17、Memento(備忘錄模式)；18、Mediator(中介者模式)；19、Command(命令模式)。20、Visitor(訪問者模式)；21、Chain of Responsibility(責任鏈模式)；22、Iterator(叠代器模式)；23、Interpreter(解釋器模式).

Factory Method：定義一個用於創建對象的接口。讓子類決定將哪一個類實例化。Factory Method使一個類的實例化延遲到其子類。

Abstract Factory：提供一個創建一系列相關或相互依賴對象的接口。而無需指定他們詳細的類。

Singleton：保證一個類僅有一個實例，並提供一個訪問它的全局訪問點。

Builder：將一個復雜對象的構建與它的表示分離，使得相同的構建過程能夠創建不同的表示。

Prototype：用原型實例指定創建對象的種類。而且通過拷貝這個原型來創建新的對象。

Bridge：將抽象部分與它的實現部分分離，使它們都能夠獨立地變化。

Adapter：將一個類的接口轉換成客戶希望的另外一個接口。

Adapter模式使得原本由於接口不兼容而不能一起工作的那些類能夠一起工作。

Decorator：動態地給一個對象加入一些額外的職責。就擴展功能而言， Decorator模式比生成子類方式更為靈活。

Composite：將對象組合成樹形結構以表示“部分-總體”的層次結構。

Composite使得客戶對單個對象和復合對象的使用具有一致性。

Flyweight：運用共享技術有效地支持大量細粒度的對象。

Facade：為子系統中的一組接口提供一個一致的界面， Facade模式定義了一個高層接口，這個接口使得這一子系統更加easy使用。

Proxy：為其它對象提供一個代理以控制對這個對象的訪問。

Template Method：定義一個操作中的算法的骨架。而將一些步驟延遲到子類中。Template Method使得子類能夠不改變一個算法的結構就可以重定義該算法的某些特定步驟。

Strategy：定義一系列的算法,把它們一個個封裝起來, 而且使它們可相互替換。本模式使得算法的變化可獨立於使用它的客戶。

State：同意一個對象在其內部狀態改變時改變它的行為。對象看起來似乎改動了它所屬的類。

Observer：定義對象間的一種一對多的依賴關系,以便當一個對象的狀態發生改變時,全部依賴於它的對象都得到通知並自己主動刷新。

Memento：在不破壞封裝性的前提下，捕獲一個對象的內部狀態，並在該對象之外保存這個狀態。這樣以後就可將該對象恢復到保存的狀態。

Mediator：用一個中介對象來封裝一系列的對象交互。中介者使各對象不須要顯式地相互引用。從而使其耦合松散。而且能夠獨立地改變它們之間的交互。

Command：將一個請求封裝為一個對象，從而使你可用不同的請求對客戶進行參數化。對請求排隊或記錄請求日誌，以及支持可取消的操作。

Visitor：表示一個作用於某對象結構中的各元素的操作。它使你能夠在不改變各元素的類的前提下定義作用於這些元素的新操作。

Chain of Responsibility：為解除請求的發送者和接收者之間耦合。而使多個對象都有機會處理這個請求。將這些對象連成一條鏈。並沿著這條鏈傳遞該請求。直到有一個對象處理它。

Iterator：提供一種方法順序訪問一個聚合對象中各個元素, 而又不需暴露該對象的內部表示。

Interpreter：給定一個語言, 定義它的文法的一種表示，並定義一個解釋器, 該解釋器使用該表示來解釋語言中的句子。

State：(1)、意圖：同意一個對象在其內部狀態改變時改變它的行為。對象看起來似乎改動了它的類。

(2)、適用性：A、一個對象的行為取決於它的狀態。而且它必須在執行時刻依據狀態改變它的行為。

B、一個操作中含有龐大的多分支的條件語句，且這些分支依賴於該對象的狀態。

這個狀態通經常使用一個或多個枚舉常量表示。

通常，有多個操作包含這一相同的條件結構。State模式將每個條件分支放入一個獨立的類中。這使得你能夠依據對象自身的情況將對象的狀態作為一個對象，這一對象能夠不依賴於其它對象而獨立變化。

(3)、相關模式：A、Flyweight模式解釋了何時以及怎樣共享狀態對象。B、狀態對象一般是Singleton。

(4)、當一個對象的行為取決於它的狀態，而且它必須在執行時刻依據狀態改變它的行為時，可考慮用到狀態模式。

(5)、在State模式中。將狀態邏輯和動作實現進行分離。當一個操作中要維護大量的case分支語句。而且這些分支依賴於對象的狀態。

State模式將每個分支都封裝到獨立的類中。State模式和Strategy模式有非常大程度上的類似：它們都有一個Context類，都是通過托付(組合)給一個具有多個派生類的多態基類實現Context的算法邏輯。

兩者最大的區別就是State模式重派生類持有指向Context對象的引用，並通過這個引用調用Context中的方法。可是Strategy模式中就沒有這樣的情況。因此能夠說一個State實例相同是Strategy模式的一個實例，反之卻不成立。

實際上State模式和Strategy模式的區別還在於它們所關註的點不盡相同：State模式主要是要適應對象對於狀態改變時的不同處理策略的實現，而Strategy則主要是詳細算法和實現接口的解耦(coupling)，Strategy模式中並沒有狀態的概念(盡管非常多時候能夠被看作是狀態的概念)，而且更加不關心狀態的改變了。State模式非常好地實現了對象的狀態邏輯和動作實現的分離，狀態邏輯分布在State的派生類中實現，而動作實現則能夠放在Context類中實現(這也是為什麽State派生類須要擁有一個指向Context的指針)。這使得兩者的變化相互獨立，改變State的狀態邏輯能夠非常easy復用Context的動作，也能夠在不影響State派生類的前提下創建Context的子類來更改或替換動作實現。

State模式問題主要是邏輯分散化，狀態邏輯分布到了非常大的State的子類中。非常難看到整個的狀態邏輯圖，這也帶來了代碼的維護問題。

演示樣例代碼1：

#include <iostream>
using namespace std;

class Work;
class ForenoonState;
class NoonState;

class State
{
public:
	virtual void WriteProgram(Work* w) = 0;
};

class Work
{
private:
	State* current;
public:
	double hour;
public:
	Work();
	void SetState(State* temp)
	{
		current = temp;
	}

	void Writeprogram()
	{
		current->WriteProgram(this);
	}
};

class NoonState : public State
{
public:
	virtual void WriteProgram(Work* w)
	{
		cout<<"execute"<<endl;

		if ((w->hour) < 13)
			cout<<"還不錯啦"<<endl;
		else
			cout<<"不行了，還是睡覺吧"<<endl;
	}
};

class ForenoonState : public State
{
public:
	virtual void WriteProgram(Work* w)
	{
		if ((w->hour) < 12)
			cout<<"如今的精神無敵好"<<endl;
		else {
			w->SetState(new NoonState());
			w->Writeprogram();//註意加上這句
		}

	}
};

Work::Work()
{
	current = new ForenoonState();
}

//client
int main()
{
	Work* mywork = new Work();
	mywork->hour = 9;
	mywork->Writeprogram();
	mywork->hour = 14;
	mywork->Writeprogram();

	/*result
		如今的精神無敵好
		execute
		不行了。還是睡覺吧
	*/

	return 0;
}

演示樣例代碼2：

State.h:

#ifndef _STATE_H_
#define _STATE_H_

class Context;//前置聲明

class State
{
public:
	State();
	virtual ~State();
	virtual void OperationInterface(Context*) = 0;
	virtual void OperationChangeState(Context*) = 0;
protected:
	bool ChangeState(Context* con, State* st);
};

class ConcreteStateA : public State
{
public:
	ConcreteStateA();
	virtual ~ConcreteStateA();
	virtual void OperationInterface(Context*);
	virtual void OperationChangeState(Context*);
protected:
private:
};

class ConcreteStateB : public State
{
public:
	ConcreteStateB();
	virtual ~ConcreteStateB();
	virtual void OperationInterface(Context*);
	virtual void OperationChangeState(Context*);
protected:
private:
};

#endif//~_STATE_H_

State.cpp:

#include "State.h"
#include "Context.h"
#include <iostream>

using namespace std;

State::State()
{

}

State::~State()
{

}

void State::OperationInterface(Context* con)
{
	cout<<"State:: ..."<<endl;
}

bool State::ChangeState(Context* con, State* st)
{
	con->ChangeState(st);
	return true;
}

void State::OperationChangeState(Context* con)
{

}

ConcreteStateA::ConcreteStateA()
{

}

ConcreteStateA::~ConcreteStateA()
{

}

void ConcreteStateA::OperationInterface(Context* con)
{
	cout<<"ConcreteStateA::OperationInterface ..."<<endl;
}

void ConcreteStateA::OperationChangeState(Context* con)
{
	OperationInterface(con);
	this->ChangeState(con, new ConcreteStateB());
}

ConcreteStateB::ConcreteStateB()
{

}

ConcreteStateB::~ConcreteStateB()
{

}

void ConcreteStateB::OperationInterface(Context* con)
{
	cout<<"ConcreteStateB::OperationInterface ..."<<endl;
}

void ConcreteStateB::OperationChangeState(Context* con)
{
	OperationInterface(con);
	this->ChangeState(con, new ConcreteStateA());
}

Context.h:

#ifndef _CONTEXT_H_
#define _CONTEXT_H_

class State;

class Context
{
public:
	Context();
	Context(State* state);
	~Context();
	void OperationInterface();
	void OperationChangeState();
protected:
private:
	friend class State;//表明在State類中能夠訪問Context類的private字段
	bool ChangeState(State* state);
private:
	State* _state;
};


#endif//~_CONTEXT_H_

Context.cpp:

#include "Context.h"
#include "State.h"

Context::Context()
{

}

Context::Context(State* state)
{
	this->_state = state;
}

Context::~Context()
{
	delete _state;
}

void Context::OperationInterface()
{
	_state->OperationInterface(this);
}

bool Context::ChangeState(State* state)
{
	//_state->ChangeState(this, state);
	this->_state = state;

	return true;
}

void Context::OperationChangeState()
{
	_state->OperationChangeState(this);
}

main.cpp:

#include "Context.h"
#include "State.h"
#include <iostream>

using namespace std;

int main()
{
	State* st = new ConcreteStateA();
	Context* con = new Context(st);
	con->OperationChangeState();
	con->OperationChangeState();
	con->OperationChangeState();

	if (con != NULL)
		delete con;

	if (st != NULL)
		st = NULL;

	/*result
		ConcreteStateA::OperationInterface ...
		ConcreteStateB::OperationInterface ...
		ConcreteStateA::OperationInterface ...
	*/

	return 0;
}

狀態模式結構圖：

技術分享

參考文獻：

1、《大話設計模式C++》

2、《設計模式精解----GoF23種設計模式解析》

3、《設計模式----可復用面向對象軟件的基礎》

設計模式之狀態模式(State)摘錄

表示 facade test true efi 子類 ble 叠代系列 23種GOF設計模式一般分為三大類：創建型模式、結構型模式、行為模式。創建型模式抽象了實例化過程，它們幫助一個系統獨立於怎樣創建、組合和表示它的那些對象。一個類創建型模式使用繼承改變被實例化的類，而

設計模式之狀態模式(State)摘錄

設計模式之狀態模式(State)摘錄

設計模式之- 狀態模式（State Pattern）

設計模式之狀態模式（State Pattern）

設計模式之狀態模式(State)

設計模式之狀態模式

C++設計模式之狀態模式(二)

Head First設計模式之狀態模式

C++設計模式之狀態模式

大話設計模式之狀態模式

ES設計模式之狀態模式

設計模式之狀態模式(行為型)

23種設計模式之狀態模式

Unity設計模式之狀態模式

Java設計模式之狀態模式

專案中使用的設計模式之狀態模式

折騰Java設計模式之狀態模式

設計模式之狀態模式（三）

設計模式之狀態模式實戰

行為型模式之狀態模式

23種設計模式之 State模式（狀態模式） C語言

設計模式之狀態模式(State)摘錄

相關推薦