状态模式：用类表示状态

在不使用状态模式之前，我们经常通过

if(state1) {
	// do state1 something
} else if(state2) {
	// do state2 something
} else {
	// do other something
}

在状态设计模式中，对象根据其内部状态的不同而改变其行为。这样，对象可以看起来像它们已经改变了类。状态模式通过将每个特定状态的行为封装在单独的类中来实现这一点。这些类被称为“状态类”，并且它们通常会实现一个公共的接口或抽象类。这个接口/抽象类定义了在特定状态下对象应该具有的所有方法。

示例代码

// DoorState interface
interface DoorState {
    void open();
    void close();
    void lock();
    void unlock();
}

// OpenedState class
class OpenedState implements DoorState {
    public void open() {
        System.out.println("The door is already opened");
    }
    
    public void close() {
        System.out.println("Closing the door");
        Door.setState(Door.getClosedState());
    }
    
    public void lock() {
        System.out.println("The door must be closed before it can be locked");
    }
    
    public void unlock() {
        System.out.println("The door is already unlocked");
    }
}

// ClosedState class
class ClosedState implements DoorState {
    public void open() {
        System.out.println("Opening the door");
        Door.setState(Door.getOpenedState());
    }
    
    public void close() {
        System.out.println("The door is already closed");
    }
    
    public void lock() {
        System.out.println("Locking the door");
        Door.setState(Door.getLockedState());
    }
    
    public void unlock() {
        System.out.println("The door is not locked");
    }
}

// LockedState class
class LockedState implements DoorState {
    public void open() {
        System.out.println("The door is locked, it cannot be opened");
    }
    
    public void close() {
        System.out.println("The door is locked, it cannot be closed");
    }
    
    public void lock() {
        System.out.println("The door is already locked");
    }
    
    public void unlock() {
        System.out.println("Unlocking the door");
        Door.setState(Door.getClosedState());
    }
}

// Door class
class Door {
    private DoorState currentState;
    private static final DoorState OPENED_STATE = new OpenedState();
    private static final DoorState CLOSED_STATE = new ClosedState();
    private static final DoorState LOCKED_STATE = new LockedState();
    
    public Door() {
        currentState = CLOSED_STATE;
    }
    
    public void setState(DoorState state) {
        currentState = state;
    }
    
    public DoorState getCurrentState() {
        return currentState;
    }
    
    public static DoorState getOpenedState() {
        return OPENED_STATE;
    }
    
    public static DoorState getClosedState() {
        return CLOSED_STATE;
    }
    
    public static DoorState getLockedState() {
        return LOCKED_STATE;
    }
    
    public void open() {
        currentState.open();
    }
    
    public void close() {
        currentState.close();
    }
    
    public void lock() {
        currentState.lock();
    }
    
    public void unlock() {
        currentState.unlock();
    }
}

// Example usage
Door door = new Door();
door.lock(); // prints "The door is already locked"
door.unlock(); // prints "Unlocking the door"
door.lock(); // prints "Locking the door"
door.open(); // prints "Opening the door"
door.close(); // prints "Closing the door"

在上面的示例中，我们创建了一个门对象和三个状态类：OpenedState、ClosedState和LockedState。每个状态类都实现了DoorState接口，并定义了在特定状态下门应该具有的所有方法，同时Door对象将会持有DoorState对象，通过使用当前持有DoorState对象进行操作，而DoorState实现类对象也应该存入Door对象以便修改Door对象操作后的状态。