如何用Java Enum实现状态机

在Java中，使用枚举（Enum）实现状态机是一种简洁且类型安全的方式。下面是一个简单的示例，展示了如何使用枚举来实现一个有限状态机（Finite State Machine, FSM）。

首先，定义一个状态接口，这个接口将包含状态机的行为：

public interface State {
    void onEnter(); // 进入状态时调用
    void onExit();  // 退出状态时调用
    void onEvent(Event event); // 处理事件
}

然后，定义事件类，这些事件将触发状态转换：

public class Event {
    public final String name;

    public Event(String name) {
        this.name = name;
    }
}

接下来，创建一个具体的状态枚举，每个枚举常量都是一个状态，并实现State接口：

public enum States implements State {
    START {
        @Override
        public void onEnter() {
            System.out.println("Entering START state");
        }

        @Override
        public void onExit() {
            System.out.println("Exiting START state");
        }

        @Override
        public void onEvent(Event event) {
            if ("to_middle".equals(event.name)) {
                StateContext.getInstance().changeState(MIDDLE);
            }
        }
    },
    MIDDLE {
        @Override
        public void onEnter() {
            System.out.println("Entering MIDDLE state");
        }

        @Override
        public void onExit() {
            System.out.println("Exiting MIDDLE state");
        }

        @Override
        public void onEvent(Event event) {
            if ("to_end".equals(event.name)) {
                StateContext.getInstance().changeState(END);
            } else if ("to_start".equals(event.name)) {
                StateContext.getInstance().changeState(START);
            }
        }
    },
    END {
        @Override
        public void onEnter() {
            System.out.println("Entering END state");
        }

        @Override
        public void onExit() {
            System.out.println("Exiting END state");
        }

        @Override
        public void onEvent(Event event) {
            // END状态是最终状态，通常不会有事件处理
        }
    };

    public abstract void onEnter();
    public abstract void onExit();
    public abstract void onEvent(Event event);
}

现在，创建一个状态上下文类，它将维护当前状态并提供改变状态的方法：

public class StateContext {
    private static StateContext instance;
    private State currentState;

    private StateContext() {
        currentState = States.START; // 初始状态
        currentState.onEnter(); // 进入初始状态
    }

    public static synchronized StateContext getInstance() {
        if (instance == null) {
            instance = new StateContext();
        }
        return instance;
    }

    public void changeState(States newState) {
        currentState.onExit(); // 退出当前状态
        currentState = newState; // 改变状态
        currentState.onEnter(); // 进入新状态
    }

    public void handleEvent(Event event) {
        currentState.onEvent(event); // 处理事件
    }
}

最后，你可以使用这个状态机：

public class Main {
    public static void main(String[] args) {
        StateContext context = StateContext.getInstance();

        // 触发一些事件
        context.handleEvent(new Event("to_middle"));
        context.handleEvent(new Event("to_end"));
        context.handleEvent(new Event("invalid_event")); // 这个事件不会引起状态变化
    }
}

这个例子中的状态机是非并发的，也就是说它不是线程安全的。如果你需要在多线程环境中使用状态机，你需要添加适当的同步机制。此外，这个状态机的设计比较简单，它没有考虑到状态的进入和退出条件，也没有考虑到状态转换的验证等高级特性。在实际应用中，你可能需要根据具体需求对这个基础模型进行扩展。