状态模式

发表于 更新于 分类于 ， 阅读次数：
本文字数： 10k 阅读时长 ≈ 9 分钟

状态模式UML类图

状态模式UML类图

状态模式java实现

/**
 * State interface.
 */
public interface State {

  void onEnterState();

  void observe();

}

/**
 * Peaceful state.
 和平状态。
 */
public class PeacefulState implements State {

  private static final Logger LOGGER = LoggerFactory.getLogger(PeacefulState.class);

  private Mammoth mammoth;

  public PeacefulState(Mammoth mammoth) {
    this.mammoth = mammoth;
  }

  @Override
  public void observe() {
      //平静与和平的。
    LOGGER.info("{} is calm and peaceful.", mammoth);
  }

  @Override
  public void onEnterState() {
      //冷静下来
    LOGGER.info("{} calms down.", mammoth);
  }

}

/**
 * Angry state.
 愤怒的状态
 */
public class AngryState implements State {

  private static final Logger LOGGER = LoggerFactory.getLogger(AngryState.class);

  private Mammoth mammoth;

  public AngryState(Mammoth mammoth) {
    this.mammoth = mammoth;
  }

  @Override
  public void observe() {
      //很生气
    LOGGER.info("{} is furious!", mammoth);
  }

  @Override
  public void onEnterState() {
      //生气了！
    LOGGER.info("{} gets angry!", mammoth);
  }

}

/**
 * Mammoth has internal state that defines its behavior.
 长毛象具有定义其行为的内部状态。
 */
public class Mammoth {

  private State state;

  public Mammoth() {
    state = new PeacefulState(this);
  }

  /**
   * Makes time pass for the mammoth.
   */
  public void timePasses() {
    if (state.getClass().equals(PeacefulState.class)) {
      changeStateTo(new AngryState(this));
    } else {
      changeStateTo(new PeacefulState(this));
    }
  }

  private void changeStateTo(State newState) {
    this.state = newState;
    this.state.onEnterState();
  }

  @Override
  public String toString() {
    return "The mammoth";
  }

  public void observe() {
    this.state.observe();
  }
}

/**
 * In State pattern the container object has an internal state object that defines the current
 * behavior. The state object can be changed to alter the behavior.
 *
 * <p>This can be a cleaner way for an object to change its behavior at runtime without resorting
 * to large monolithic conditional statements and thus improves maintainability.
 *
 * <p>In this example the {@link Mammoth} changes its behavior as time passes by.
 在“状态”模式中，容器对象具有定义当前行为的内部状态对象。 可以更改状态对象以更改行为。
<p>这可能是对象在运行时更改其行为的更干净的方法，而无需诉诸大型整体式条件语句，从而提高了可维护性。
<p>在此示例中，{@ link Mammoth}随着时间的流逝而改变其行为。
 */
public class App {

  /**
   * Program entry point.
   */
  public static void main(String[] args) {

    var mammoth = new Mammoth();
    mammoth.observe();
    mammoth.timePasses();
    mammoth.observe();
    mammoth.timePasses();
    mammoth.observe();

  }
}

极客时间

马里奥

//所有状态的接口
public interface IMario {
  State getName();
  //以下是定义的事件
  //获得蘑菇
  void obtainMushRoom();
  //获得斗篷
  void obtainCape();
  //获得火花
  void obtainFireFlower();
  //遇见怪物
  void meetMonster();
}
//小马里奥
public class SmallMario implements IMario {
  private MarioStateMachine stateMachine;
  public SmallMario(MarioStateMachine stateMachine) {
    this.stateMachine = stateMachine;
  }
  public State getName() {
    return State.SMALL;
  }
  public void obtainMushRoom() {
    stateMachine.setCurrentState(new SuperMario(stateMachine));
    stateMachine.setScore(stateMachine.getScore()+100)
  }
  public void obtainCape() {
    stateMachine.setCurrentState(new CapeMario(stateMachine));
    stateMachine.setScore(stateMachine.getScore()+200);
  }
  public void obtainFireFlower() {
    stateMachine.setCurrentState(new FireMario(stateMachine));
    stateMachine.setScore(stateMachine.getScore()+300);
  }
  public void meetMonster() {
    //do nothing...
  }
}
//超级马里奥
public class SuperMario implements IMario {
  private MarioStateMachine stateMachine;
  public SuperMario(MarioStateMachine stateMachine) {
    this.stateMachine = stateMachine;
  }
  public State getName(){
    return State.SUPER;
  }
  public void obtainMushRoom() {
    //do nothing...
  }
  public void obtainCape() {
    stateMachine.setCurrentState(new CapeMario(stateMachine));
    stateMachine.setScore(stateMachine.getScore() + 200);
  }
  public void obtainFireFlower() {
    stateMachine.setCurrentState(new FireMario(stateMachine));
    stateMachine.setScore(stateMachine.getScore() + 300);
  }
  public void meetMonster() {
    stateMachine.setCurrentState(new SmallMario(stateMachine));
    stateMachine.setScore(stateMachine.getScore() - 100);
  }
}
//火焰马里奥
public class FireFlowerMario implements IMario {
  private MarioStateMachine stateMachine;
  public FireFlowerMario(MarioStateMachine stateMachine) {
    this.stateMachine = stateMachine;
  }
  public State getName(){
    return State.FireFlower;
  }
  public void obtainMushRoom() {
    //do nothing...
  }
  public void obtainCape() {
    //do nothing...
  }
  public void obtainFireFlower() {
    //do nothing...
  }
  public void meetMonster() {
    stateMachine.setCurrentState(new SmallMario(stateMachine));
    stateMachine.setScore(stateMachine.getScore() - 100);
  }
}
//斗篷马里奥
public class CapeMario implements IMario {
  private MarioStateMachine stateMachine;
  public CapeMario(MarioStateMachine stateMachine) {
    this.stateMachine = stateMachine;
  }
  public State getName(){
    return State.Cape;
  }
  public void obtainMushRoom() {
    //do nothing...
  }
  public void obtainCape() {
    //do nothing...
  }
  public void obtainFireFlower() {
    //do nothing...
  }
  public void meetMonster() {
    stateMachine.setCurrentState(new SmallMario(stateMachine));
    stateMachine.setScore(stateMachine.getScore() - 100);
  }
}
public class MarioStateMachine {
  private int score;
  private IMario currentState;
  public MarioStateMachine() {
    this.score = 0;
    this.currentState = new SmallMario(this);
  }
  public void obtainMushRoom() {
    this.currentState.obtainMushRoom();
  }
  public void obtainCape() {
    this.currentState.obtainCape();
  }
  public void obtainFireFlower() {
    this.currentState.obtainFireFlower();
  }
  public void meetMonster() {
    this.currentState.meetMonster();
  }
  public int getScore() {
    return this.score;
  }
  public State getCurrentState() {
    return this.currentState.getName();
  }
  public void setScore(int score) {
    this.score = score;
  }
  public void setCurrentState(IMario currentState) {
    this.currentState = currentState;
  }
}

项目实战

订单状态

/**
 * 订单状态 //待付款 //待收货 //已完成 //已取消
 */

/**
 * 支付状态  //待支付 //已支付 //待退款 //已退款
 */

public interface OrderStatus {

  /**
   * 支付
   */
  void payOrder();

  /**
   * 取消订单
   */
  void cancelOrder();

  /**
   * 确认完成
   */
  void completeOrder();

  /**
   * 申请售后
   */
  void applyForAfterSales();

  /**
   * 再次购买
   */
  void buyAgain();
}

/**
 * 待付款
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ToBePaidStatus implements OrderStatus {

  Order order;

  @Override
  public void payOrder() {
    order.setStatus(new ToBeReceivedStatus(order));
    System.out.println("======调用支付宝支付接口======");
  }

  @Override
  public void cancelOrder() {
    order.setStatus(new CancelStatus(order));
  }

  @Override
  public void completeOrder() {
    try {
      throw new Exception("你还未付款，请去支付页面");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  @Override
  public void applyForAfterSales() {
    try {
      throw new Exception("你还未付款，请去支付页面");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  @Override
  public void buyAgain() {
    try {
      throw new Exception("你还未付款，请去支付页面");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  @Override
  public String toString() {
    return "待付款状态";
  }
}

/**
 * 待收货
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ToBeReceivedStatus implements OrderStatus {

  Order order;

  @Override
  public void payOrder() {
    try {
      throw new Exception("您已经支付过了");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  @Override
  public void cancelOrder() {
    order.setStatus(new CancelStatus(order));
    //发起退款逻辑
    System.out.println("======触发退款逻辑======");
  }

  @Override
  public void completeOrder() {
    //触发订单完成逻辑
    System.out.println("======触发订单完成逻辑======");
    order.setStatus(new CompleteStatus(order));
  }

  @Override
  public void applyForAfterSales() {
    try {
      throw new Exception("你还未收货");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  @Override
  public void buyAgain() {
    try {
      throw new Exception("你还未收货");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  @Override
  public String toString() {
    return "待收货状态";
  }
}

/**
 * 已完成
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CompleteStatus implements OrderStatus {

  Order order;

  @Override
  public void payOrder() {
    try {
      throw new Exception("您已经确认完成过了");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  @Override
  public void cancelOrder() {
    try {
      throw new Exception("您已经确认完成过了");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  @Override
  public void completeOrder() {
    try {
      throw new Exception("您已经确认完成过了");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  @Override
  public void applyForAfterSales() {
    //触发申请售后逻辑
    System.out.println("======触发申请售后逻辑======");
  }

  @Override
  public void buyAgain() {
    //再次购买逻辑
  }

  @Override
  public String toString() {
    return "已完成状态";
  }
}

/**
 * 已取消
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CancelStatus implements OrderStatus {

  Order order;

  @Override
  public void payOrder() {
    try {
      throw new Exception("您已经取消过了");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  @Override
  public void cancelOrder() {
    try {
      throw new Exception("您已经取消过了");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  @Override
  public void completeOrder() {
    try {
      throw new Exception("您已经取消过了");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  @Override
  public void applyForAfterSales() {
    try {
      throw new Exception("您已经取消过了");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  @Override
  public void buyAgain() {
    //再次购买逻辑
  }

  @Override
  public String toString() {
    return "已取消状态";
  }
}

public class Order {

  private Long id;
  //订单状态
  private OrderStatus status;
  //支付状态
//  private PayType payType;

  public Order() {
    //初始化订单状态和支付状态
    status = new ToBePaidStatus(this);
  }

  public OrderStatus getStatus() {
    return status;
  }

  public void setStatus(OrderStatus status) {
    this.status = status;
  }

  public void payOrder() {
    status.payOrder();
  }

  public void completeOrder() {
    status.completeOrder();
  }

  public void cancelOrder() {
    status.cancelOrder();
  }

  public void applyForAfterSales() {
    status.applyForAfterSales();
  }

  public void buyAgain() {
    status.buyAgain();
  }

}

public class OrderTest {

  public static void main(String[] args) {
    /**
     * 下单
     */
    Order order = new Order();
    System.out.println(order.getStatus());

    /**
     * 支付
     */
    order.payOrder();
    System.out.println(order.getStatus());
//    /**
//     * 取消
//     */
//    order.cancelOrder();
//    System.out.println(order.getStatus());
    /**
     * 完成
     */
    order.completeOrder();
    System.out.println(order.getStatus());
    /**
     * 申请售后
     */
    order.applyForAfterSales();
    System.out.println(order.getStatus());
  }
}