Heim > Java > javaLernprogramm > Hauptteil

So implementieren Sie eine Java-Zustandsmaschine

WBOY
Freigeben: 2023-05-14 11:40:06
nach vorne
2617 Leute haben es durchsucht

Angenommen, wir haben zwei Zustände.

So implementieren Sie eine Java-Zustandsmaschine

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 So implementieren Sie eine Java-Zustandsmaschine

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;
        }
     
    }
    Nach dem Login kopieren
    public interface Event {
     
        public String handle();
     
    }
    Nach dem Login kopieren
    public class PlayBasketballEvent implements Event{
        @Override
        public String handle() {
            System.out.println("开始打篮球");
            return "开始打篮球";
        }
    }
    Nach dem Login kopieren

    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";
        }
    }
    Nach dem Login kopieren
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
}
Nach dem Login kopieren

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;
    }
 
}
Nach dem Login kopieren

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!

Verwandte Etiketten:
Quelle:yisu.com
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage