chapter10_事务的状态——状态模式

策略模式和状态模式是极其相似的两种设计模式

在不使用状态模式前, 状态的转换需要通过多个if或者switch完成(这种做法叫做程序状态机PSM)

GumballMachine.java

  public class GumballMachine {

      final static int SOLD_OUT = 0;
      final static int NO_QUARTER = 1;
      final static int HAS_QUARTER = 2;
      final static int SOLD = 3;

      int state = SOLD_OUT;
      int count = 0;

      public GumballMachine(int count) {

          this.count = count;
   
          if (count > 0) {
              state = NO_QUARTER;
          }
      }

      public void insertQuarter() {

          if (state == HAS_QUARTER) {

              System.out.println("You can't insert another quarter");

          } else if (state == NO_QUARTER) {

              state = HAS_QUARTER;
              System.out.println("You inserted a quarter");

          } else if (state == SOLD_OUT) {

              System.out.println("You can't insert a quarter, the machine is sold out");

          } else if (state == SOLD) {

              System.out.println("Please wait, we're already giving you a gumball");
          }
      }

      public void ejectQuarter() {

          if (state == HAS_QUARTER) {

              System.out.println("Quarter returned");
              state = NO_QUARTER;

          } else if (state == NO_QUARTER) {

              System.out.println("You haven't inserted a quarter");

          } else if (state == SOLD) {
      
              System.out.println("Sorry, you already turned the crank");

          } else if (state == SOLD_OUT) {

              System.out.println("You can't eject, you haven't inserted a quarter yet");
          }
      }

      ...

  }

另外如果需要添加新的状态, 需要在现有的方法中增加很多新的代码, 容易出现问题

(2) 状态模式会将每个状态封装成一个类的对象, 在进行状态转换时, 不再用if进行判断, 而是在状态对象内部进行转换

State.java

  public interface State {

      void insertQuarter();

      void ejectQuarter();

      void turnCrank();

      void dispense();

      void refill();
  }

State是一个接口, 它定义了几个状态转换方法

GumballMachine.java

  public class GumballMachine {

      private State soldOutState;
      private State noQuarterState;
      private State hasQuarterState;
      private State soldState;

      private State state;
      private int count = 0;

      public GumballMachine(int numberGumballs) {

          soldOutState = new SoldOutState(this);
          noQuarterState = new NoQuarterState(this);
          hasQuarterState = new HasQuarterState(this);
          soldState = new SoldState(this);

          this.count = numberGumballs;

          if (numberGumballs > 0) {
              state = noQuarterState;
          } else {
              state = soldOutState;
          }
      }

      public void insertQuarter() {
          state.insertQuarter();
      }

      public void ejectQuarter() {
          state.ejectQuarter();
      }

      public void turnCrank() {

          state.turnCrank();
          state.dispense();
      }

      ...
  }

GumballMachine是一个用户, 它内部包含了几种状态, 每个状态是一个对象, 在需要进行状态转换的时候, 将状态转换的任务__委托__给内部的state对象

SoldState.java

  public class SoldState implements State {

      private GumballMachine gumballMachine;

      public SoldState(GumballMachine gumballMachine) {

          this.gumballMachine = gumballMachine;
      }

      public void insertQuarter() {

          System.out.println("Please wait, we're already giving you a gumball");
      }

      public void ejectQuarter() {

          System.out.println("Sorry, you already turned the crank");
      }

      public void turnCrank() {

          System.out.println("Turning twice doesn't get you another gumball!");
      }

      public void dispense() {

          gumballMachine.releaseBall();

          if (gumballMachine.getCount() > 0) {
              gumballMachine.setState(gumballMachine.getNoQuarterState());
          } else {
              System.out.println("Oops, out of gumballs!");
              gumballMachine.setState(gumballMachine.getSoldOutState());
          }
      }

      public void refill() {
      }

      public String toString() {

          return "dispensing a gumball";
      }
  }

SoldState是State接口的一个具体的实现类, 它实现了在需要进行状态转换的时候, 当前的状态应该如何转换;

扫描二维码关注公众号，回复： 5337052 查看本文章

在构造器中, SoldState关联了一个GumballMachine, 这样在某些状态转换时可以更改GumballMachine的状态, 例如gumballMachine.setState(gumballMachine.getSoldOutState());

(3) 如果GumballMachine中增加了新的状态, 那么只需要添加一种新的状态类, 然后实现它, 并且改写和新状态关联的某些状态类的某些方法即可, 这样就实现了解耦

状态模式

允许对象在内部状态改变时改变它的行为, 对象看起来好像修改了它的类

说明:

1° 外部操纵的类是__Context类__, 它包含了一些内部状态;

2° __State接口__定义了所有状态必须实现的方法;

3° 每添加一种状态, 就添加一种State的实现类;

4° 不管什么时候, 只要调用了Context的方法, 都会__委托__给内部的State对象来处理
状态模式和策略模式的对比

(1) 两者有着相同的类图

(2) 两者的区别在于__意图__:

状态模式是将一群行为封装在状态对象中, 对于Context的客户在调用Context的方法时甚至不知道内部的状态对象, 因为Context采取了委托的机制, 这样在Context中就不需要进行各种条件判断了;

策略模式是客户要主动指定Context所要组合的策略对象是哪一个, 客户是很清楚它set的内部策略对象的
前面的示例其实是将各个State进行封闭, 但这样也造成了一个问题就是各个State的实现类是有依赖的;

如果状态转换是固定的, 那么应该在Context类中决定状态转换的流向;

如果转换是动态的, 那么应该放在各个State实现类中。
如果想让多个Context共享几个状态, 那么可以把几个State对象定义为static, 但是要注意多线程的同步问题

chapter10_事务的状态——状态模式

猜你喜欢