《java与模式》学习之状态模式

行为模式是对在不同的对象之间划分责任和算法的抽象化。行为模式不仅仅是关于类和对象的，而且是关于他们之间的相互作用的。

行为模式分位类的行为模式和对象的行为模式两种。

1.类的行为模式 类的行为模式使用继承关系在类之间分配行为。

2.对象的行为模式 对象的行为模式则使用对象的聚合来分配行为。

---------《java与模式》阎宏

状态模式把所有研究对象的行为包装在不同的状态对象里，每一个状态对象都属于状态类的一个子类。状态模式的意图是让一个对象在其内部状态改变的时候，其行为也随之改变。State模式典型的结构图为：

模式设计的角色有：

1.抽象状态(State)角色：定义一个接口，用以封装环境(Context)对象的一个特定的状态所对应的行为。

2.具体状态(ConcreteState)角色：每一个具体状态类都实现了环境(Context)的一个状态所对应的行为。

3。环境(Context)角色：定义客户端所感兴趣的接口，并且保留一个具体状态类的实例。这个具体状态类的实例给出此环境对象的现有状态。

状态模式常常用在当一个对象的状态过于复杂的情况，把对应不同的逻辑封装在一个状态类里，把逻辑梳理更加直观简单。

我用了一个点灯开关状态的简单例子来实现一个及其简单的状态模式：

Context.h

#pragma once
#include <memory>

class State;

class Context : public std::enable_shared_from_this<Context>
{
public:
	Context(std::shared_ptr<State> pState);
	~Context();

	virtual void ChangeState(std::shared_ptr<State> pState);

	virtual void Operate() = 0;
protected:
	std::shared_ptr<State> m_pShareCurrentState;
};

Context.cpp

#include "stdafx.h"
#include "Context.h"

Context::Context(std::shared_ptr<State> pState)
{
	m_pShareCurrentState = pState;
}

Context::~Context()
{
}

void Context::ChangeState(std::shared_ptr<State> pState)
{

}

State.h

#pragma once
#include <memory>

class Context;

class State
{
public:
	State();
	virtual ~State();

	virtual void Operate(std::shared_ptr<Context>& pContext) = 0;
};

State.cpp

#include "stdafx.h"
#include "State.h"

State::State()
{
}

State::~State()
{
}

LightContext.h

#pragma once

#include "Context.h"

class LightStateOff;
class LightStateOn;

class LightContext : public Context
{
public:
	LightContext(std::shared_ptr<State> pState);
	~LightContext();

	virtual void ChangeState(std::shared_ptr<State> pState) override;

	virtual void Operate() override;
};

LightContext.cpp

#include "stdafx.h"
#include "LightContext.h"
#include "LightState.h"


LightContext::LightContext(std::shared_ptr<State> pState) : Context(pState)
{
}

LightContext::~LightContext()
{
}

void LightContext::ChangeState(std::shared_ptr<State> pState)
{
	m_pShareCurrentState = pState;
}

void LightContext::Operate()
{
	m_pShareCurrentState->Operate(shared_from_this());
}

LightState.h

#pragma once

#include "State.h"

class LightStateOff;

class LightStateOn : public State
{
public:
	LightStateOn();
	~LightStateOn();

	virtual void Operate(std::shared_ptr<Context>& pContext) override;

protected:
	std::shared_ptr<LightStateOff> m_pSharedOffState;
};

class LightStateOff : public State
{
public:
	LightStateOff();
	~LightStateOff();

	virtual void Operate(std::shared_ptr<Context>& pContext) override;

protected:
	std::shared_ptr<LightStateOn> m_pSharedOnState;
};

LightState.cpp

#include "stdafx.h"
#include "LightState.h"
#include "LightContext.h"
#include <iostream>

/// LightStateOn //
LightStateOn::LightStateOn()
{
}

LightStateOn::~LightStateOn()
{

}

void LightStateOn::Operate(std::shared_ptr<Context>& pContext)
{
	std::cout << " Current State is On, Change 2 off" << std::endl;
	if (!m_pSharedOffState)
	{
		m_pSharedOffState = std::make_shared<LightStateOff>();
	}
	pContext->ChangeState(m_pSharedOffState);
}

// LightStateOff /
LightStateOff::LightStateOff()
{
}

LightStateOff::~LightStateOff()
{

}

void LightStateOff::Operate(std::shared_ptr<Context>& pContext)
{
	std::cout << " Current State is Off, Change 2 On " << std::endl;
	if (!m_pSharedOnState)
	{
		m_pSharedOnState = std::make_shared<LightStateOn>();
	}
	pContext->ChangeState(m_pSharedOnState);
}

main.cpp

#include "stdafx.h"
#include <memory>
#include "LightContext.h"
#include "LightState.h"

int main()
{
	std::shared_ptr<LightStateOff> pLightStateOff = std::make_shared<LightStateOff>();
	std::shared_ptr<LightContext> pLightContext = std::make_shared<LightContext>(pLightStateOff);
	pLightContext->Operate();
	pLightContext->Operate();


    return 0;
}