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

    这种模式看起来类似于“策略”模式，但有一个关键的区别。在状态模式中，特定状态可能彼此了解，并开始从一个状态过渡到另一个状态，而策略几乎永远不会彼此了解。

    【角色】

    • 抽象状态角色（State）：接口或抽象类，负责对象状态定义，并且封装环境角色以实现状态切换。
    • 具体状态角色（ConcreteState）：每一个具体状态必须完成两个职责：本状态的行为管理以及趋向状态处理，通俗地说，就是本状态下要做的事情，以及本状态如何过渡到其他状态。
    • 环境角色（Context）：定义客户端需要的接口，并且负责具体状态的切换。

    【优点】

    • 符合单一职责原则：将与特定状态相关的代码组织到单独的类中。
    • 符合开放封闭原则：在不更改现有状态类或上下文的情况下引入新状态。

    【缺点】

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

    • 如果类只有几个状态或很少更改，应用状态模式可能会过度设计。

      1. /**
      2. * 抽象状态类
      3. */
      4. public abstract class State {
      6.   /**
      7.    * 台灯
      8.    */
      9.   protected Lamp lamp;
      11.   public State(Lamp lamp) {
      12.       this.lamp = lamp;
      13.   }
      15.   /**
      16.    * 切换灯光
      17.    */
      18.   abstract void change();
      19. }
      1. /**
      2. * 正常光状态
      3. *
      4. * @author yupan
      5. * @date 7/18/21 12:29 PM
      6. */
      7. public class NormalState extends State {
      9.   public NormalState(Lamp lamp) {
      10.       super(lamp);
      11.       System.out.println("正常光");
      12.   }
      14.   @Override
      15.   public void change() {
      16.       // 变成"强光"
      17.       super.lamp.setState(new HighState(super.lamp));
      18.   }
      19. }
      1. /**
      2. * 强光状态
      3. */
      4. public class HighState extends State {
      6.   public HighState(Lamp lamp) {
      7.       super(lamp);
      8.       System.out.println("强光");
      9.   }
      11.   @Override
      12.   public void change() {
      13.       // 变成"弱光"
      14.       super.lamp.setState(new LowState(super.lamp));
      15.   }
      16. }
      1. /**
      2. * 弱光状态
      3. */
      4. public class LowState extends State {
      6.   public LowState(Lamp lamp) {
      7.       super(lamp);
      8.       System.out.println("弱光");
      9.   }
      11.   @Override
      12.   public void change() {
      13.       // 变成"关闭"
      14.       super.lamp.setState(new CloseState(super.lamp));
      15.   }
      16. }
      1. /**
      2. * 关闭状态
      3. */
      4. public class CloseState extends State {
      6.   public CloseState(Lamp lamp) {
      7.       super(lamp);
      8.       System.out.println("关闭");
      9.   }
      11.   @Override
      12.   public void change() {
      13.       // 变成"正常光"
      14.       super.lamp.setState(new NormalState(super.lamp));
      15.   }
      16. }
      1. /**
      2. * 台灯
      3. */
      4. public class Lamp {
      6.   private State state;
      8.   public Lamp() {
      9.       // 默认关闭状态
      10.       this.state = new CloseState(this);
      11.   }
      13.   public void setState(State state) {
      14.       this.state = state;
      15.   }
      17.   public void click() {
      18.       this.state.change();
      19.   }
      20. }
      1. public class StateTest {
      2.   public static void main(String[] args) {
      3.       // 台灯默认关闭
      4.       Lamp lamp = new Lamp();
      5.       // 正常光
      6.       lamp.click();
      7.       // 强光
      8.       lamp.click();
      9.       // 弱光
      10.       lamp.click();
      11.       // 关闭
      12.       lamp.click();
      13.       // 正常光
      14.       lamp.click();
      15.   }
      16. }
      17. ----输出----
      18. 关闭
      19. 正常光
      20. 强光
      21. 弱光
      22. 关闭
      23. 正常光