这将是有限状态机吗？

Question

public interface State {
    void processOne();
    void processTwo();
    void processThree();
}

public class AStateImplOne implements State {

    @Override
    public void processOne() {
        doStuff();
    }


    @Override
    public void processTwo() {
        doStuff();
    }


    @Override
    public void processThree() {
        doStuff();
    }

    private void doStuff() {}

}

public class AStateImplTwo implements State {


    @Override
    public void processOne() {
        doStuff();
    }


    @Override
    public void processTwo() {
        doStuff();
    }


    @Override
    public void processThree() {
        doStuff();
    }

    private void doStuff() {}

}

public class StateMachine {    
    private State one = new AStateImplOne();
    private State two = new AStateImplTwo();
    private State state;

    public int loop() {
        checkState();
        state.processOne();
        state.processTwo();
        state.processThree();
        return 0;
    }

    private void checkState() {
        if (condition) {
            state = one;
        } else {
            state = two;
        }
    }
}

This is my code. I want to create a finite state machine for a game (loop() is continuously called) and whilst I was reading up on FSMs I realised that it would make my code much better. However, I don't think this is a correct implementation on one. Could someone please verify for me? All help much appreciated.

Answer 1

One way:

interface State {
  abstract void process(int d);
}
class Machine {
  State state;
  class State1 implements State {
    process(int d) {
      switch(d) {
        case 1: ...; state=...; break;
        case 2: ...; state=...; break;
      }
    }
  }
  class State2 implements State {
    ...
  }
}

Answer 2

In that special case you may call it finite state machine, but you are doing it wrong. The whole point of finite state machines is that the next state depends on in what state the finite state machine is actually at, not on some arbitrary condition that chooses one state out of many. It works, but definitely it is not the best solution.

You probably wanted to do something like this:

public enum FiniteStateMachine
{    
    StateOne
    {
        @Override
        public void processOne()
        {
            System.out.print("I am in the state One\n");
        }

        @Override
        public FiniteStateMachine nextState(final boolean condition)
        {
            if(condition)
            {
                return StateTwo;
            }
            return StateOne;
        }
    },
    StateTwo
    {
        @Override
        public void processOne()
        {
            System.out.print("I am in the state Two\n");
        }

        @Override
        public FiniteStateMachine nextState(final boolean condition)
        {
            if(condition)
            {
                return StateOne;
            }
            return StateTwo;
        }

    };

    abstract public void processOne();
    abstract public FiniteStateMachine nextState(final boolean condition);
}

And that's how it works:

public static void main(final String[] args)
{
    FiniteStateMachine state = FiniteStateMachine.StateOne;
    state.processOne();
    state = state.nextState(true);
    state.processOne();
}

Output: I am in the state One I am in the state Two

You can even use it the way you have used it in your example:

private FiniteStateMachine checkState(Condition condition)
{
    if(condition.isTrue())
    {
        return FiniteStateMachine.StateOne;
    }
    return FiniteStateMachine.StateTwo;
}

But remember it is incorrect way of using it;

Tip for game: Google MVC pattern, it might come in handy during game developement.