状态模式

// State接口
public interface State {
    void handle();
}

// ConcreteStateA类（开状态）
public class OnState implements State {
    @Override
    public void handle() {
        System.out.println("电灯已经开启。");
    }
}

// ConcreteStateB类（关状态）
public class OffState implements State {
    @Override
    public void handle() {
        System.out.println("电灯已经关闭。");
    }
}

// Context类
public class LightSwitch {
    private State currentState;

    public LightSwitch() {
        // 初始状态为关
        this.currentState = new OffState();
    }

    public void setState(State state) {
        this.currentState = state;
    }

    public void press() {
        currentState.handle();
        // 状态切换
        if (currentState instanceof OffState) {
            setState(new OnState());
        } else {
            setState(new OffState());
        }
    }
}

// 客户端代码
public class StatePatternDemo {
    public static void main(String[] args) {
        LightSwitch lightSwitch = new LightSwitch();

        lightSwitch.press(); // 打开电灯
        lightSwitch.press(); // 关闭电灯
        lightSwitch.press(); // 打开电灯
        lightSwitch.press(); // 关闭电灯
    }
}

// State接口
public interface CharacterState {
    void handle();
}

// ConcreteStateA类（正常状态）
public class NormalState implements CharacterState {
    @Override
    public void handle() {
        System.out.println("角色处于正常状态，可以自由移动和攻击。");
    }
}

// ConcreteStateB类（受伤状态）
public class InjuredState implements CharacterState {
    @Override
    public void handle() {
        System.out.println("角色受伤，移动速度减慢，攻击力降低。");
    }
}

// ConcreteStateC类（死亡状态）
public class DeadState implements CharacterState {
    @Override
    public void handle() {
        System.out.println("角色已死亡，无法进行任何操作。");
    }
}

// Context类
public class GameCharacter {
    private CharacterState currentState;

    public GameCharacter() {
        // 初始状态为正常
        this.currentState = new NormalState();
    }

    public void setState(CharacterState state) {
        this.currentState = state;
    }

    public void performAction() {
        currentState.handle();
    }
}

// 客户端代码
public class StatePatternGameDemo {
    public static void main(String[] args) {
        GameCharacter character = new GameCharacter();

        character.performAction(); // 正常状态

        character.setState(new InjuredState());
        character.performAction(); // 受伤状态

        character.setState(new DeadState());
        character.performAction(); // 死亡状态
    }
}

// State接口
public interface OrderState {
    void handle(OrderContext context);
}

// ConcreteStateA类（新建状态）
public class NewState implements OrderState {
    @Override
    public void handle(OrderContext context) {
        System.out.println("订单已创建，等待处理。");
        context.setState(new ProcessingState());
    }
}

// ConcreteStateB类（处理中状态）
public class ProcessingState implements OrderState {
    @Override
    public void handle(OrderContext context) {
        System.out.println("订单正在处理中。");
        context.setState(new ShippedState());
    }
}

// ConcreteStateC类（已发货状态）
public class ShippedState implements OrderState {
    @Override
    public void handle(OrderContext context) {
        System.out.println("订单已发货。");
        context.setState(new CompletedState());
    }
}

// ConcreteStateD类（已完成状态）
public class CompletedState implements OrderState {
    @Override
    public void handle(OrderContext context) {
        System.out.println("订单已完成。");
    }
}

// ConcreteStateE类（已取消状态）
public class CancelledState implements OrderState {
    @Override
    public void handle(OrderContext context) {
        System.out.println("订单已取消。");
    }
}

// Context类
public class OrderContext {
    private OrderState currentState;

    public OrderContext() {
        this.currentState = new NewState();
    }

    public void setState(OrderState state) {
        this.currentState = state;
    }

    public void process() {
        currentState.handle(this);
    }

    // 取消订单的方法
    public void cancel() {
        if (!(currentState instanceof CompletedState) && !(currentState instanceof CancelledState)) {
            setState(new CancelledState());
            System.out.println("订单被取消。");
        } else {
            System.out.println("无法取消订单，订单已完成或已取消。");
        }
    }
}

// 客户端代码
public class StatePatternOrderDemo {
    public static void main(String[] args) {
        OrderContext order = new OrderContext();

        order.process(); // 新建 -> 处理中
        order.process(); // 处理中 -> 已发货
        order.cancel();  // 已发货 -> 已取消
        order.process(); // 已取消，无法继续处理
    }
}