设置模式－状态模式

来源：《设计模式之禅》

定义：当一个对象在改变状态时容许改变其行为，这个对象看起来像改变了其类。状态模式的核心时封装，状态的改变引发了行为的改变，从外部看来好像是这个对象的对应的类发生了改变。

状态模式三个角色：

1. State抽象状态角色：负责对象状态定义，封装环境角色以实现状态切换。

2. ConcreteState 具体状态角色：实现抽象状态角色定义。具体状态两个主要职责，本状态行为管理和取向状态处理。

3. Context 环境角色：定义客户端须要的接口，负责具体状态的切换。

类图：

代码：

抽象状态

/**
 * 
 */
package cc.pattern.state;

/**
 * @author rico
 * 抽象状态
 */
public abstract class State {
	protected Context context;
	
	public void setContext(Context context) {
		this.context = context;
	}
	
	public abstract void handleOne();
	
	public abstract void handlerTwo();
}

具体状态

/**
 * 
 */
package cc.pattern.state;

/**
 * @author rico
 * 具体状态
 */
public class StateOne extends State {

	/* (non-Javadoc)
	 * @see cc.pattern.state.State#handleOne()
	 */
	@Override
	public void handleOne() {
		super.context.setCurrentState(Context.stateTwo);
		super.context.handleOne();
	}

	/* (non-Javadoc)
	 * @see cc.pattern.state.State#handlerTwo()
	 */
	@Override
	public void handlerTwo() {
		System.out.println("###StateOne.handlerTwo...");
	}

}

/**
 * 
 */
package cc.pattern.state;

/**
 * @author rico
 * 具体状态
 */
public class StateTwo extends State {

	/* (non-Javadoc)
	 * @see cc.pattern.state.State#handleOne()
	 */
	@Override
	public void handleOne() {
		System.out.println("###StateTwo.handleOne...");
	}

	/* (non-Javadoc)
	 * @see cc.pattern.state.State#handlerTwo()
	 */
	@Override
	public void handlerTwo() {
		super.context.setCurrentState(Context.stateOne);
		super.context.handleTwo();
	}

}

上下文

/**
 * 
 */
package cc.pattern.state;

/**
 * @author rico
 * 上下文
 */
public class Context {
	public static final StateOne stateOne = new StateOne();
	public static final StateTwo stateTwo = new StateTwo();
	
	// 当前状态
	private State currentState;
	
	public void setCurrentState(State state) {
		this.currentState = state;
		this.currentState.setContext(this);
	}
	
	public void handleOne() {
		this.currentState.handleOne();
	}
	
	public void handleTwo() {
		this.currentState.handlerTwo();
	}
	
}

场景类

/**
 * 
 */
package cc.pattern.state;

/**
 * @author rico
 * 场景类
 */ 
public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Context context = new Context();
		//context.setCurrentState(new StateTwo());
		context.setCurrentState(new StateOne());
		
		context.handleOne();
		context.handleTwo();
	}

}

状态模式优势：

1. 结构清晰，避免过多的switch 或 if，下降程序的复杂性，提升系统的可维护性。

2. 遵循了开闭原则和单一原则 。

3. 封装性很是好。外部的调用不须要知道类内部状态和行为的切换。

状态模式肯定：

1.  状态太多，类回膨胀。

使用场景：

1. 行为随状态改变的场景。

2. 条件／分支判断语句的替代。

扩展：