Finite State Machine

Question

hello dear coders. I'm a software engineering student and i have an assignment to create an Elevator Simulator using various programming patterns.
One of them is the an advance form of the State Pattern from Gang of Fours, the Finite State Machine.
On assignment delivery i have to justify every choice i made in implementing the patterns. I have my understanding of the FSM ( finite state machine) but i don't know if it's even near the correct form.
I'll post the classes I've made for a elevator simulator, and i would appreciate if you give me your opinion and state what i could improve and why.
I'll post also the possible state changes for the simulator requested by teacher.
States : [http://img201.imageshack.us/img201/6150/stateskz6.th.jpg]
Since they are in portuguese i'll give you the translation:
Porta Fechada = Door Closed
Porta Aberta = Door Open
Ascendente = Going up
Descendente = Going down
Parado = Stopped ( or idle )
class : StateMachine
* @author bruno
public class StateMachine {
    private AbstractState state;
    private AbstractState globalState;
    private AbstractState previousState;
    public StateMachine(AbstractState state, AbstractState globalState, AbstractState previousState) {
        this.state = state;
        this.globalState = globalState;
        this.previousState = previousState;
    public StateMachine() {
        this.state = new StateStopped();
        this.globalState = new StateGoingUp();
        this.previousState = new StateGoingUp();
    public void update() {
        if (state instanceof StateDoorClosed) {
            if (previousState instanceof StateGoingUp || previousState instanceof StateGoingDown) {
                this.changeState(this.getState().open());
            } else if (previousState instanceof StateDoorOpen || previousState instanceof StateDoorClosed) {
                this.changeState(this.getState().execute());
        } else if (state instanceof StateStopped && !(globalState instanceof StateStopped)) {
            if (globalState instanceof StateGoingUp) {
                this.changeState(this.getState().up());
            } else {
                this.changeState(this.getState().down());
        } else {
            this.changeState(this.getState().execute());
    public AbstractState getState() {
        return state;
    public AbstractState getGlobalstate() {
        return globalState;
    public void setState(AbstractState state) {
        this.state = state;
    public void setGlobalState(AbstractState globalState) {
        this.globalState = globalState;
    public AbstractState getPreviousState() {
        return previousState;
    public void setPreviousState(AbstractState previousState) {
        this.previousState = previousState;
    public void changeState(AbstractState newState) {
        this.setPreviousState(state);
        this.setState(newState);
}class : AbstractState
* @author bruno
public abstract class AbstractState {
    protected AbstractState state;
    public abstract AbstractState execute();
    public abstract AbstractState up();
    public abstract AbstractState down();
    public abstract AbstractState open();
    public abstract AbstractState close();
    public AbstractState getState() {
        return state;
    public AbstractState(AbstractState state) {
        this.state = state;
    public AbstractState() {
        this.state = this;
    public void setState(AbstractState state) {
        this.state = state;
}I omitted the concrete State Classes because of length, if you would like me to post them as-well please, don't hesitate to ask.
Sorry for the bad English and for the length of the post.
THANK YOU IN ADVANCE!

Answer 1

>
Two things with this code:
public void update() {
if (state instanceof StateDoorClosed) {
if (previousState instanceof StateGoingUp || previousState instanceof StateGoingDown) {
this.changeState(this.getState().open());
} else if (previousState instanceof StateDoorOpen || previousState instanceof StateDoorClosed) {
this.changeState(this.getState().execute());
} else if (state instanceof StateStopped && !(globalState instanceof StateStopped)) {
if (globalState instanceof StateGoingUp) {
this.changeState(this.getState().up());
} else {
this.changeState(this.getState().down());
} else {
this.changeState(this.getState().execute());
}Firstly, that doesn't look like a finite state machine. In a FSM the next state depends on the current state and the input it receives, whereas your machine it depends on the previous state and the global state, and no input.
Secondly, almost always if you're using instanceof to change behaviour, you're doing something wrong. It's useful for testing data you've received from a general purpose channel, such as some serialisation mechanisms or an implementation of string formatting, but it shouldn't be in the core of classes where you've designed both sides of the contract.
Usually you implement either a general purpose method to return the next state from a state given its input, or (as you have done) provide several methods to cope with the different inputs and return the next state. So the core execution logic would be for a general transition method.
  get input from outside
  state = state.transition(input)or for specific methods:
  get input from outside
  switch input
    case open: state = state.open()
    case close: state = state.close()The diagram you posted is too small to read, but it doesn't seem to have any inputs marked on the transitions, which makes the whole thing indeterminate, unless the inputs for each transition are recorded elsewhere.
Your AbstractState has a reference to another state - why ? It should either have one state for each transition out of it, or none (for example, if you make each state instance an nested class of the machine, or use an enum for the states, they don't need anything other than a transition() method, and no fields)