设计模式：策略模式和状态模式

目前看了一些设计模式，但是还有的记不住，现在感觉策略模式与状态模式非常像，于是想写点东西．
首先看了一下菜鸟上的说明 策略模式和 状态模式因此想做一下分析，深入理解一下两个模式的区别．

策略模式

首先我们可以看一下什么是策略模式，我总结了以下几点：
１）需要针对不同的环境，使用不同的策略
２）不同的策略中实现了不同的方法
３）将策略传入环境中，策略中的方法去解决环境中的问题

基于上面的几个点，我们来写一下实现方法

/*
	策略基类，里面有一个策略方法
*/
public class StrategyBase {
	virtual public void doOperation();
}

/*
	有几个策略q r f 
*/
public class Strategy_A : public StrategyBase {
	public void doOperation() {
		std::cout << "q 它试探一下" <<std::endl;
	}
}

public class Strategy_B : public StrategyBase {
	public void doOperation() {
		std::cout << "交闪现　溜了溜了" <<std::endl;
	}
}

public class Strategy_D : public StrategyBase {
	public void doOperation() {
		std::cout << "交大　硬刚" <<std::endl;
	}
}

/*
	创建不同的状态
*/
public class context {
	private StrategyBase* m_Strategy;
	
	public void context(StrategyBase* newStrategy) {
		m_Strategy = newStrategy;
	}
	
	public void do(){
		m_Strategy->doOperation();
	}
}

/*
	使用　传入不同的方法去实现不同机能
*/
public class Demo {
	private Context* context;
	
	public static void Main() {
		context = new Context(new Strategy_A()); 
		context->do();

		context = new Context(new Strategy_B()); 
		context->do();

		context = new Context(new Strategy_C()); 
		context->do();
	}
}

这个实现非常的简单，就是说　一个基类方法被子类重写，然后子类对象，基类指针指向子类的对象，调用的就是重写的子类的方法，这个就是大家熟悉的多态

状态模式

状态模式，就是通过不同的状态，表现不同的行为．这么一看策略模式也是这样呀．其实还是不同的
１）拥有一个环境，根据不同的环境设计不同的策略
２）状态切换可以在子类中完成
３）“不同状态的切换可由子类实现”，即状态模式的状态间往往是具有耦合性的，而策略模式算法簇之间完全解耦。
４）状态模式将各个状态所对应的操作分离开来，即对于不同的状态，由不同的子类实现具体操作，不同状态的切换由子类实现，当发现传入参数不是自己这个状态所对应的参数，则自己给Context类切换状态；而策略模式是直接依赖注入到Context类的参数进行选择策略，不存在切换状态的操作。

StatusA mStatusA = new StatusA( mContext)


public class StatusA {
	StatusA(Context context) {

	}
	void do1() {
		print ("StatusA do1");
	}
	void do2() {
		print ("StatusA do２");
	}
}

public class StatusB {
	StatusA(Context context) {

	}
	void do1() {
		print ("StatusB do1");
	}
	void do2() {
		print ("StatusB do２");
	}
}

public class Context() {
	StatusBasic* mStatus = null;
	StatusA* mStatusA = new StatusA();
	StatusB* mStatusB = new StatusB();
	
	private setState(StatusBasic* newStatus) {
		mStatus = newStatus;
	}

	doAction_1() {
		setState(mStatusA);
		mStatus->do1();
	}
	doAction_2() {
		mStatus->do2();
	}
}

后面总结一下　，　context这个环境中做了一些事情，状态就改变了，这个是外部没有感知的，不知道Context的状态改变，然后继续操作的时候，发现结果不一样了．

int main() {
Context context = new Context();
context.doAction_1();
context.doAction_2();
}

int main() {
Context context = new Context();
context.doAction_2();
}

doAction_2的执行结果是不一样的，因为无感知状态改变了