So implementieren Sie eine Java-Zustandsmaschine

Angenommen, wir haben zwei Zustände.

Dieser Zustandsübergang ist sehr einfach. Versuchen wir, ihn in Java zu implementieren Wie Sie sehen, gibt es vier Größen, die den Zustand darstellen, nämlich:

currentState: stellt den aktuellen Zustand dar

action: stellt die entsprechende Aktion dar

• nextState: stellt den nächsten Zustand dar

• event: stellt das entsprechende Ereignis dar

• Die Bedeutung dieses Vier-Tupels besteht darin, dass im Status currentState eine Aktion in den Status nextState übertragen wird und die Ereignisantwort ausgelöst wird.
  Achten Sie auf die vier Methoden der Ketteninitialisierung. Die Definition dieser vier Methoden macht die Statusinitialisierung sehr elegant.
• Werfen wir einen Blick auf Ereignisse, die diese Schnittstelle implementieren, um bestimmte Vorgänge auszuführen.

  public class StateTransaction {
   
      // 当前状态
      private StateEnum currentState;
      // 相对应动作
      private ActionEnum action;
      // 下一个状态
      private StateEnum nextState;
      // 相应事件
      private Event event;
   
      public StateTransaction() {
   
      }
   
      public StateEnum getCurrentState() {
          return currentState;
      }
   
      public ActionEnum getAction() {
          return action;
      }
   
      public StateEnum getNextState() {
          return nextState;
      }
   
      public Event getEvent() {
          return event;
      }
   
      // 链式初始化对象
      public StateTransaction source(StateEnum state) {
          currentState = state;
          return this;
      }
      public StateTransaction when(ActionEnum action) {
          this.action = action;
          return this;
      }
      public StateTransaction target(StateEnum state) {
          nextState = state;
          return this;
      }
      public StateTransaction how(Event event) {
          this.event = event;
          return this;
      }
   
  }

  public interface Event {
   
      public String handle();
   
  }

  public class PlayBasketballEvent implements Event{
      @Override
      public String handle() {
          System.out.println("开始打篮球");
          return "开始打篮球";
      }
  }

  Darüber hinaus müssen wir zwei Aufzählungsklassen definieren um den Status bzw. die Aktion darzustellen

public class SingDanceRapEvent implements Event{
    @Override
    public String handle() {
        System.out.println("开始唱，跳，rap");
        return "开始唱，跳，rap";
    }
}

Nachdem die oben genannten Vorbereitungen abgeschlossen sind, benötigen wir eine Zustandsmaschinenklasse, um die Zustandsübertragung durchzuführen

public enum StateEnum {
    // 打篮球
    PLAY_BASKETBALL,
    // 唱跳rap
    SING_DANCE_RAP
}
public enum ActionEnum {
    // 音乐起
    MUSIC_ON,
    // 音乐结束
    MUSIC_OFF
}

Der obige Code enthält zwei Schlüsselmethoden, nämlich addone( ) undexecute()

Lassen Sie uns Sprechen Sie zuerst über addone(). Die Methode initialisiert zunächst ein StateTransaction-Objekt, fügt es dann in die Liste ein und gibt schließlich das Objekt zurück. Sobald wir dieses Objekt erhalten, können wir den Inhalt ausfüllen.

Lassen Sie uns noch einmal über „execute()“ sprechen. Diese Methode empfängt ActionEnum als Parameter und durchläuft dann die Liste, um eine Statusinformation des nächsten Objekts zu finden, das durch Ändern des aktuellen Status durch die entsprechende Aktion erhalten wird handle() in der Event-Methode und übertrage den aktuellen Status und gebe schließlich StateTransaction zurück, oder null, wenn nicht gefunden.

Werfen wir zum Schluss einen Blick auf die Initialisierungsmethode

public class StateMachine {
 
    // 存储状态信息
    private List<StateTransaction> stateTransactionList;
    // 记录当前状态
    private StateEnum currentState;
 
    public StateMachine(StateEnum state) {
        currentState = state;
        stateTransactionList = new ArrayList<>();
    }
 
    // 添加一条状态信息
    public StateTransaction addone() {
        StateTransaction stateTransaction = new StateTransaction();
        stateTransactionList.add(stateTransaction);
        return stateTransaction;
    }
 
    // 进行状态转移
    public StateTransaction execute(ActionEnum action) {
        for(int i=0; i<stateTransactionList.size(); i++) {
            if(currentState==stateTransactionList.get(i).getCurrentState() &&
                action==stateTransactionList.get(i).getAction()) {
                stateTransactionList.get(i).getEvent().handle();
                currentState = stateTransactionList.get(i).getNextState();
                return stateTransactionList.get(i);
            }
        }
        return null;
    }
 
}

Sie können sehen, dass wir mithilfe der Kettenmethode direkt eine Statusübertragungsnachricht erstellen können, was sehr elegant ist

Die Programmausgabe lautet wie folgt

Das obige ist der detaillierte Inhalt vonSo implementieren Sie eine Java-Zustandsmaschine. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!