《JAVA与模式》之状态模式

在阎宏博士的《JAVA与模式》一书中开头是这样描述状态（State）模式的：

　　状态模式，又称状态对象模式（Pattern of Objects for States），状态模式是对象的行为模式。

　　状态模式允许一个对象在其内部状态改变的时候改变其行为。这个对象看上去就像是改变了它的类一样。

状态模式的结构

　　用一句话来表述，状态模式把所研究的对象的行为包装在不同的状态对象里，每一个状态对象都属于一个抽象状态类的一个子类。状态模式的意图是让一个对象在其内部状态改变的时候，其行为也随之改变。状态模式的示意性类图如下所示：

aaarticlea/png;base64,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" alt="" />

　　状态模式所涉及到的角色有：

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

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

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

---

状态模式跟策略模式有点像,对比后单纯的从代码结构来看,会发现状态模式多了一个state,这个state是在各个state实现类中的开关

举个例子,风扇有一档,二档和三档,当你按下一档,二档和三档处于可按状态,当你按下二档,一档和三档处于可按状态。好别扭看着,不过说明了他跟策略模式的本质区别

1.策略模式是并行的,而状态模式是互斥的

2.状态模式是内部自己控制的,而策略模式是client控制的(客户端必须知道有多少中策略模式)

 public class State {

     public static void main(String[] args) {

         /*BadState badState =new BadState(1);
         badState.say();*/

         IState state=new BlueState();
         ContextState context=new ContextState(state);
         System.out.println(context.getState().getState());
         context.push();

         System.out.println(context.getState().getState());
     }

 }

 /**
  *
  * 这个是简单点的情况
  * 复杂点 加入有三个状态  有1  则下个状态 必然是 2  上个状态是1 ‘
  * 状态是2  上一个状态是1  下个状态是 3
  * 以此类推
  *
  * 假如有五个状态以上  估计代码就很难维护了
  * */
 class  BadState{

     private int state ;

     public BadState(int state){

         this.state=state;
     }

     public void say(){

         switch (state) {
         case 1:
             System.out.println(" hello ");
             break;
         case 2:
             System.out.println(" hi ");
             break;

         default:
             break;
         }

     }

 }

 class ContextState {
     /***
      *      红
      *   蓝           绿
      * */

     private IState state;

     public ContextState (IState state){
         this.state =state;

     }

     public IState getState() {
         return state;
     }

     public void setState(IState state) {
         this.state = state;
     }

     public void  push(){

         state.next(this);

     }
     public void  pull(){

         state.prev(this);

     }

 }

 interface IState{

     public void prev(ContextState c);

     public void next(ContextState c);

     public String getState();

 }

 /***
  *      红
  *   蓝           绿
  * */

 class BlueState implements IState{

     @Override
     public void prev(ContextState c) {

         c.setState(new RedState());
     }

     @Override
     public void next(ContextState c) {
         // TODO Auto-generated method stub

         c.setState(new GreenState());
     }

     @Override
     public String getState() {
         // TODO Auto-generated method stub
         return "blue";
     }
 }
 /***
  *      红
  *   蓝           绿
  * */

 class GreenState implements IState{

     @Override
     public void prev(ContextState c) {

         c.setState(new BlueState());
     }

     @Override
     public void next(ContextState c) {
         c.setState(new RedState());

     }

     @Override
     public String getState() {
         // TODO Auto-generated method stub
         return "green";
     }
 }
 /***
  *      红
  *   蓝           绿
  * */

 class RedState implements IState{

     @Override
     public void prev(ContextState c) {

         c.setState(new GreenState());
     }

     @Override
     public void next(ContextState c) {
         c.setState(new BlueState());

     }

     @Override
     public String getState() {
         // TODO Auto-generated method stub
         return "red";
     }
 }

ps:通过策略模式+工厂模式 可以比较好的解决if else过多的问题  当然这时候 使用策略模式+工厂模式

也是可以的,因为有多少种情况(策略)你肯定知道的

参考:http://www.cnblogs.com/java-my-life/archive/2012/06/08/2538146.html