Comment implémenter la machine à états Java

Supposons que nous ayons deux états

Cette transition d'état est très simple, essayons de l'implémenter en java

La structure du programme est comme indiqué ci-dessous

Introduisons d'abord la représentation de l'état

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;
    }
 
}

Vous pouvez le voir, il y a quatre grandeurs représentant l'état, à savoir :

• currentState : représente l'état actuel

• action : représente l'action correspondante

• nextState : représente l'état suivant

• event : représente l'événement correspondant

La signification de ce quatre-tuple est que dans l'état currentState, si une action se produit, elle sera transférée à l'état nextState et la réponse à l'événement événement sera déclenchée.

Faites attention aux quatre méthodes d'initialisation de la chaîne. La définition de ces quatre méthodes rend l'initialisation de l'état très élégante.

Jetons un coup d'œil aux événements. L'événement est une interface. D'autres événements spécifiques implémentent cette interface pour effectuer certaines opérations. Notre programme imprimera certaines informations directement sans effectuer d'opérations compliquées

public interface Event {
 
    public String handle();
 
}

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

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

De plus, nous devons également définir deux classes d'énumération. pour représenter respectivement les états et les actions

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

Une fois les préparatifs ci-dessus terminés, nous avons besoin d'une classe de machine d'état pour effectuer le transfert d'état

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;
    }
 
}

Il y a deux méthodes clés dans le code ci-dessus, à savoir addone() etexecute()

Voyons parlons d'abord de addone(). La méthode initialise d'abord un objet StateTransaction, puis le place dans la liste et renvoie enfin l'objet. Une fois que nous obtenons cet objet, nous pouvons remplir le contenu.

Parlons à nouveau d'execute(). Cette méthode reçoit ActionEnum comme paramètre, puis parcourt la liste pour trouver une information d'état de l'objet suivant obtenue en modifiant l'état actuel via l'action correspondante. handle() dans la méthode event. et transfère l’état actuel, et enfin renvoie StateTransaction, ou null s’il n’est pas trouvé.

Enfin, jetons un coup d'œil à la méthode d'initialisation

public class StateMachineTest {
 
    public static void main(String[] args) {
        StateMachine machine = new StateMachine(StateEnum.PLAY_BASKETBALL);
        // 打篮球的时候，一旦音乐起，就会开始唱跳rap
        machine.addone().source(StateEnum.PLAY_BASKETBALL).when(ActionEnum.MUSIC_ON)
                .target(StateEnum.SING_DANCE_RAP).how(new SingDanceRapEvent());
        // 唱跳rap的时候，一旦音乐停止，就会开始打篮球
        machine.addone().source(StateEnum.SING_DANCE_RAP).when(ActionEnum.MUSIC_OFF)
                .target(StateEnum.PLAY_BASKETBALL).how(new PlayBasketballEvent());
        machine.execute(ActionEnum.MUSIC_ON);
        machine.execute(ActionEnum.MUSIC_OFF);
    }
 
}

Vous pouvez voir que nous pouvons créer un message de transfert d'état directement en utilisant la méthode de la chaîne, ce qui est très élégant

Le résultat du programme est le suivant

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!