1.为什么会有状态模式？

1. 具体点说就是在特定状态下才能做特定事
2.面试会问
3.程序首先是给人阅读的，然后才是机器执行

核心：每一个具体状态必须完成两个职责：本状态的行为管理以及趋向状态处理，通俗地说，就是本状态下要做的事情，以及本状态如何过渡到其他状态。

2.简介

 当一个对象内在状态改变时允许其改变行为，这个对象看起来像改变了其类。
 状态模式的核心是封装，状态的变更引起了行为的变更，从外部看起来就好像这个对象
 对应的类发生了改变一样。
 
● State——抽象状态角色接口或抽象类，负责对象状态定义，并且封装环境角色以实现状态切换。

● ConcreteState——具体状态角色

     每一个具体状态必须完成两个职责：本状态的行为管理以及趋向状态处理，通俗地说，
     就是本状态下要做的事情，以及本状态如何过渡到其他状态。

● Context——环境角色


定义客户端需要的接口，并且负责具体状态的切换

3.使用场景

     ● 行为随状态改变而改变的场景

    这也是状态模式的根本出发点，例如权限设计，人员的状态不同即使执行相同的行为结

    果也会不同，在这种情况下需要考虑使用状态模式。

    ● 条件、分支判断语句的替代者

    在程序中大量使用switch语句或者if判断语句会导致程序结构不清晰，逻辑混乱，使用

    状态模式可以很好地避免这一问题，它通过扩展子类实现了条件的判断处理
    
          而且使用时对象的状态最好不要超过5个

4.优缺点

优点：

 ● 结构清晰

避免了过多的switch...case或者if...else语句的使用，避免了程序的复杂性,提高系统的可

维护性。

● 遵循设计原则

很好地体现了开闭原则和单一职责原则，每个状态都是一个子类，你要增加状态就要增

加子类，你要修改状态，你只修改一个子类就可以了。

● 封装性非常好

这也是状态模式的基本要求，状态变换放置到类的内部来实现，外部的调用不用知道类

内部如何实现状态和行为的变换。

缺点：

     状态模式既然有优点，那当然有缺点了。但只有一个缺点，子类会太多，也就是类膨

胀。如果一个事物有很多个状态也不稀奇，如果完全使用状态模式就会有太多的子类，不好

管理，这个需要大家在项目中自己衡量。其实有很多方式可以解决这个状态问题，如在数据

库中建立一个状态表，然后根据状态执行相应的操作，这个也不复杂

5. 案例

需求：

  1 上下文环境（Context）：它定义了客户程序需要的接口并维护一个具体状态角色的实例，将与状态相关的操作委托给当前的Concrete State对象来处理。
  2 抽象状态（State）：定义一个接口以封装使用上下文环境的的一个特定状态相关的行为。
  3 具体状态（Concrete State）：实现抽象状态定义的接口。

这里代码是别人的案例：

1.抽象状态

public 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();
}

2.上下文环境

// 上下文类  状态过渡
public class Context {

   //定义出所有的电梯状态
   public final static OpenningState openningState = new OpenningState();
   public final static ClosingState closeingState = 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();
   }
}

3.具体状态

public class ClosingState extends  LiftState{

  //电梯门关了再打开
  @Override
  public void open() {
      super.context.setLiftState(Context.openningState);
      //置为敞门状态
      super.context.getLiftState().open();
  }
  //电梯门关闭，这是关闭状态要实现的动作
  @Override
  public void close() {
      System.out.println("电梯门关闭...");
  }
  //电梯门关了就运行，这是再正常不过了
  @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 class OpenningState extends  LiftState{

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

    @Override
    public void close() {
        System.out.println("乘客全部进入电梯");
        //状态修改
        super.context.setLiftState(Context.closeingState);
        //动作委托为CloseState来执行
        super.context.getLiftState().close();
    }

    //门开着时电梯就运行跑，这电梯，吓死你！
    @Override
    public void run() {

    }

    //开门还不停止？
    @Override
    public void stop() {

    }
}

//运行状态
public class RunningState extends  LiftState{

   //运行的时候开电梯门？你疯了！电梯不会给你开的
   @Override
   public void open() {
       System.out.println("运行的时候开电梯门？你疯了！电梯不会给你开的");
   }
   //电梯门关闭？这是肯定的
   @Override
   public void close() {

   }
   //这是在运行状态下要实现的方法
   @Override
   public void run() {
       System.out.println("电梯上下运行...");
   }

   //这绝对是合理的，只运行不停止还有谁敢坐这个电梯？！估计只有上帝了
   @Override
   public void stop() {

       System.out.println("乘客全部下电梯");
       super.context.setLiftState(Context.stoppingState);
       //环境设置为停止状态
       super.context.getLiftState().stop();
   }
}

//停止状态
public class StoppingState extends  LiftState{
    //停止状态，开门，那是要的！
    @Override
    public void open() {
        super.context.setLiftState(Context.openningState);
        super.context.getLiftState().open();
    }
    //停止状态关门？电梯门本来就是关着的！
    @Override
    public void close() {

    }
    //停止状态再运行起来，正常得很
    @Override
    public void run() {
        super.context.setLiftState(Context.runningState);
        super.context.getLiftState().run();
    }
    //停止状态是怎么发生的呢？当然是停止方法执行了
    @Override
    public void stop() {
        System.out.println("电梯停止了...");
    }
}

4.使用

public class DianTi {

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

5.效果

3.状态模式

1.为什么会有状态模式？

2.简介

3.使用场景

4.优缺点

5. 案例