How to implement a FSM - Finite State Machine in Java

Implementing a Finite State Machine (FSM) in Java can typically be achieved by defining a series of states (State) and transitions (Transition). Each state represents the system's condition at a particular moment, while transitions define the process of moving from one state to another under specific conditions.

Here are several key steps to implement a Finite State Machine, along with a simple example:

Step 1: Define State Enumeration

First, we define an enumeration (Enum) to represent all possible states.

java
public enum States {
    STATE_INITIAL,
    STATE_INTERMEDIATE,
    STATE_FINAL
}

Step 2: Define Events

Events typically represent actions that trigger state transitions and can be represented using an enumeration.

java
public enum Events {
    EVENT_ONE,
    EVENT_TWO
}

Step 3: Define the State Machine Framework

Next, we define the state machine framework, which includes the set of states, transition logic, and the initial state:

java
public class StateMachine {
    private States currentState;

    public StateMachine() {
        currentState = States.STATE_INITIAL; // Set initial state
    }

    public void transition(Events event) {
        switch (currentState) {
            case STATE_INITIAL:
                if (event == Events.EVENT_ONE) {
                    currentState = States.STATE_INTERMEDIATE;
                }
                break;
            case STATE_INTERMEDIATE:
                if (event == Events.EVENT_TWO) {
                    currentState = States.STATE_FINAL;
                }
                break;
            // Additional transition logic
        }
    }

    public States getCurrentState() {
        return currentState;
    }
}

Step 4: Use the State Machine

Finally, we create an instance of the state machine and change its state based on events.

java
public class FSMExample {
    public static void main(String[] args) {
        StateMachine fsm = new StateMachine();
        System.out.println("Initial State: " + fsm.getCurrentState());
        // Trigger EVENT_ONE
        fsm.transition(Events.EVENT_ONE);
        System.out.println("State after EVENT_ONE: " + fsm.getCurrentState());
        // Trigger EVENT_TWO
        fsm.transition(Events.EVENT_TWO);
        System.out.println("State after EVENT_TWO: " + fsm.getCurrentState());
    }
}

This is a simple implementation of a Finite State Machine. In practical applications, state machines may become more complex, involving additional states and transitions, and may require advanced design patterns such as the State Pattern to encapsulate states and decouple transition logic.

In some cases, developers might choose to use existing state machine frameworks like Spring State Machine, which offer richer features and better maintainability.

Implementing a Finite State Machine (FSM) in Java can be achieved through various approaches, with the specific implementation varying depending on the application context and requirements. Here are two common methods:

1. Using Enums and switch-case Statements

This is a straightforward and intuitive implementation approach. We can define an enum to represent all possible states and use switch-case statements in the code to execute different behaviors based on the current state.

Example Code:

java
public class TrafficLightFSM {
    // Define all possible states
    enum State {
        RED, GREEN, YELLOW
    }

    // Current state
    private State state;

    // Constructor, initialize state
    public TrafficLightFSM() {
        state = State.RED;  // Initial state is red
    }

    // State transition logic
    public void change() {
        switch (state) {
            case RED:
                state = State.GREEN;
                break;
            case GREEN:
                state = State.YELLOW;
                break;
            case YELLOW:
                state = State.RED;
                break;
        }
        System.out.println("Current light color: " + state);
    }

    public static void main(String[] args) {
        TrafficLightFSM fsm = new TrafficLightFSM();
        fsm.change();  // Switch to green
        fsm.change();  // Switch to yellow
        fsm.change();  // Switch back to red
    }
}

2. Using the State Pattern

The State Pattern is a behavioral design pattern that allows an object to change its behavior when its internal state changes. In this pattern, state transitions typically trigger changes in the object's behavior, with each state implemented as a class that adheres to the same interface.

Example Code:

java
public interface State {
    void handle(Context context);
}

public class RedState implements State {
    @Override
    public void handle(Context context) {
        System.out.println("Current light color: Red");
        context.setState(new GreenState());
    }
}

public class GreenState implements State {
    @Override
    public void handle(Context context) {
        System.out.println("Current light color: Green");
        context.setState(new YellowState());
    }
}

public class YellowState implements State {
    @Override
    public void handle(Context context) {
        System.out.println("Current light color: Yellow");
        context.setState(new RedState());
    }
}

public class Context {
    private State state;

    public Context() {
        this.state = new RedState();  // Initial state
    }

    public void setState(State state) {
        this.state = state;
    }

    public void request() {
        state.handle(this);
    }

    public static void main(String[] args) {
        Context context = new Context();
        context.request();  // Switch to green
        context.request();  // Switch to yellow
        context.request();  // Switch back to red
    }
}

In this example, the Context class holds the current state, and each state class knows the next state to transition to, setting it within the handle() behavior method.

Summary

The choice of implementation depends on specific requirements. For scenarios with few states and simple state transition logic, using enums and switch-case is often more convenient. For complex state machines with rich state transition logic, the State Pattern provides a more modular, maintainable, and extensible solution.