行为类模式（八）：状态（State）

定义

当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。

状态模式主要解决的是当控制一个对象状态的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类中，可以把复杂的判断逻辑简化。

UML

优点

1. 把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的判断逻辑简化。
2. 将与特定状态相关的行为局部化，并且将不同状态的行为分割开来。
3. 通过把各种状态转移逻辑分不到状态与其子类之间，来减少相互间的依赖。

缺点

1. 每个具体状态类都会产生一个新类，所以会增加系统需要维护的类的数量。可以使用工厂方法来解决。

应用场景

1. 一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为。
2. 一个操作中含有庞大的多分支结构，并且这些分支决定于对象的状态。

示例

实现一个电梯运行的程序，电梯的几个状态之前可以相互切换，但是状态的改变有前置条件，比如电梯的开门状态下是不能上下跑的。

Java

 public class Main
 {
     public static void main(String[] args)
     {
         Context context = new Context();
         context.setLiftState(new ClosingState());
         context.open();
         context.close();
         context.run();
         context.stop();

         context.open();
         context.run();
     }

     public static class Context
     {
         // 定义出所有的电梯状态
         public final static OpenningState openningState = new OpenningState();
         public final static ClosingState closingState = new ClosingState();
         public final static RunningState runningState = new RunningState();
         public final static StoppingState stoppingState = new StoppingState();

         // 定一个当前电梯状态
         private LiftState liftState;

         public LiftState getLiftState()
         {
             return liftState;
         }

         public void setLiftState(LiftState liftState)
         {
             this.liftState = liftState;
             // 把当前的环境通知到各个实现类中
             this.liftState.setContext(this);
         }

         public void open()
         {
             this.liftState.open();
         }

         public void close()
         {
             this.liftState.close();
         }

         public void run()
         {
             this.liftState.run();
         }

         public void stop()
         {
             this.liftState.stop();
         }
     }

     /**
      * 定义一个电梯的接口
      */
     public static abstract class LiftState
     {
         // 定义一个环境角色，也就是封装状态的变换引起的功能变化
         protected Context context;

         public void setContext(Context _context)
         {
             this.context = _context;
         }

         // 首先电梯门开启动作
         public abstract void open();

         // 电梯门有开启，那当然也就有关闭了
         public abstract void close();

         // 电梯要能上能下，跑起来
         public abstract void run();

         // 电梯还要能停下来，停不下来那就扯淡了
         public abstract void stop();
     }

     /**
      * 在电梯门开启的状态下能做什么事情
      */
     public static class OpenningState extends LiftState
     {
         @Override
         public void close()
         {
             // 状态修改
             super.context.setLiftState(Context.closingState);
             // 动作委托为CloseState来执行
             super.context.getLiftState().close();
         }

         @Override
         public void open()
         {
             System.out.println("电梯门开启...");
         }

         @Override
         public void run()
         {
             System.out.println("电梯门开启时不能上下跑！");
         }

         @Override
         public void stop()
         {
             // do nothing;
         }
     }

     /**
      * 电梯门关闭以后，电梯可以做哪些事情
      */
     public static class ClosingState extends LiftState
     {
         @Override
         public void close()
         {
             System.out.println("电梯门关闭...");
         }

         @Override
         public void open()
         {
             super.context.setLiftState(Context.openningState); // 置为门敞状态
             super.context.getLiftState().open();
         }

         @Override
         public void run()
         {
             super.context.setLiftState(Context.runningState); // 设置为运行状态；
             super.context.getLiftState().run();
         }

         @Override
         public void stop()
         {
             super.context.setLiftState(Context.stoppingState); // 设置为停止状态；
             super.context.getLiftState().stop();
         }
     }

     /**
      * 电梯在运行状态下能做哪些动作
      */
     public static class RunningState extends LiftState
     {
         @Override
         public void close()
         {
             // do nothing
         }

         @Override
         public void open()
         {
             // do nothing
         }

         @Override
         public void run()
         {
             System.out.println("电梯上下跑...");
         }

         @Override
         public void stop()
         {
             super.context.setLiftState(Context.stoppingState);
             super.context.getLiftState().stop();
         }
     }

     /**
      * 在停止状态下能做什么事情
      */
     public static class StoppingState extends LiftState
     {
         @Override
         public void close()
         {
             // do nothing;
         }

         @Override
         public void open()
         {
             super.context.setLiftState(Context.openningState);
             super.context.getLiftState().open();
         }

         @Override
         public void run()
         {
             super.context.setLiftState(Context.runningState);
             super.context.getLiftState().run();
         }

         @Override
         public void stop()
         {
             System.out.println("电梯停止了...");
         }
     }
 }