1.步骤

1.首先要创建各状态的父类(DoorState),构造函数中传入状态的对象(Door)(改变状态时候调用)

2.创建各个状态类(DoorOpening,DoorOpen,DoorClosing,DoorClosed),重写相应的方法,方法中切换状态

3.创建状态对象类(Door),该类中也拥有所有方法,创建各个状态的对象,写成final变量的形式,方法体中由state对象调用,以调用对应的方法.(状态改变时,state对象改变,指向下一个状态的对象,调用对应的方法)

2.代码

状态父类

public abstract class DoorState {

    protected Door door;

    public abstract void touch();

    public void complete() {
    }

    public void timeout() {
    }

    public String status() {
        String s = getClass().getName();
        return s.substring(s.lastIndexOf('.') + 1);
    }

    public DoorState(Door door) {
        this.door = door;
    }
}

各子类

public class DoorOpening extends DoorState {

    public DoorOpening(Door door) {
        super(door);
    }

    @Override
    public void touch() {

    }

    @Override
    public void timeout() {
        door.setState(door.CLOSING);
    }

    public void complete() {
        door.setState(door.OPEN);
    }
}


public class DoorOpen extends DoorState {

    public DoorOpen(Door door) {
        super(door);
    }

    @Override
    public void touch() {
        door.setState(door.CLOSING);
    }
}

public class DoorClosing extends DoorState {

    public DoorClosing(Door door) {
        super(door);
    }

    @Override
    public void complete() {
        door.setState(door.CLOSED);
    }

    @Override
    public void timeout() {
        door.setState(door.OPEN);
    }

    @Override
    public void touch() {
    }
}

public class DoorClosed extends DoorState {

    public DoorClosed(Door door) {
        super(door);
    }

    @Override
    public void touch() {
        door.setState(door.OPENING);
    }
}

Door对象

public class Door extends Observable {

    public final DoorState CLOSED = new DoorClosed(this);
    public final DoorState CLOSING = new DoorClosing(this);
    public final DoorState OPEN = new DoorOpen(this);
    public final DoorState OPENING = new DoorOpening(this);
    public final DoorState STAYOPEN = new DoorStayOpen(this);

    private DoorState state = CLOSED;

    public void touch() {
        state.touch();
    }

    public void complete() {
        state.complete();
    }

    public void timeout() {
        state.timeout();
    }

    public String status() {
        return state.status();
    }

    protected void setState(DoorState state) {
        this.state = state;
        setChanged();
        notifyObservers();
    }

}


public class DoorTest {

    private static DoorTest sInstance = null;
    private static Context sContext = null;

    public static void setApplicationContext(Context ctx){
        sContext = ctx;
    }


    public static synchronized DoorTest getInstance() {
  	if(sContext == null){
            return null;
        }
        if (sInstance == null) {
            sInstance = new DoorTest();
        }
        return sInstance;
    }

    public void test() {
        Door door = new Door();

        //1. 初始状态
        System.out.println(door.status());

        //2. 转移到Opening状态
        door.touch();
        System.out.println(door.status());

        //3. 转移到Open状态
        door.complete();
        System.out.println(door.status());

        //4. 转移到Closing状态
        door.touch();
        System.out.println(door.status());

        //5. 回到Closed状态
        door.complete();
        System.out.println(door.status());
    }
}