README

状态模式：
总：
它主要用来解决对象在多种状态转换时，需要对外输出不同的行为的问题。
状态和行为是一一对应的，状态之间可以相互转换。
当一个对象的内在状态改变时，允许改变其行为，这个对象看起来像是改变了其类。

  1. e.g.<br />        1） 假如每参加一次这个活动要扣除用户 50 积分，中奖概率是 10%<br />        2） 奖品数量固定，抽完就不能抽奖<br />        3） 活动有四个状态: 可以抽奖、不能抽奖、发放奖品和奖品领完<br />        4） 活动的四个状态转换关系图(下图)(如图：奖品领完就不能再抽奖，<br />            因为“奖品领完”的节点没有后续节点)
  3. coding：<br />        1）抽象出行为，定义子类去实现父类的方法<br />        2）定义具体状态流转类<br />        3）行为子类聚合状态流转类<br />        4）状态流转类聚合行为子类，聚合行为父类<br />    状态模式的注意事项和细节<br />    （1）状态模式让代码有很强的可读性，状态模式将每个状态的行为封装到对应的一个类中。<br />    （2）方便维护。将容易产生问题的 if-else 语句删除了，如果把每个状态的行为都放到一个类中，每次调用方法时都要判断当前是什么状态，不但会产出很多 if-else 语句，而且容易出错<br />    （3）符合“开闭原则”。容易增删状态<br />    （4）会产生很多类。每个状态都要一个对应的类，当状态过多时会产生很多类，加大维护难度<br />    （5）应用场景：当一个事件或者对象有很多种状态，状态之间会相互转换，对不同的状态要求有不同的行为的时候，可以考虑使用状态模式。

状态图

状态模式本质上是一种基于状态和事件的状态机，下面是订单流程的状态图：

image.png

coding

image.png

  1. [state.java]
  2. //状态抽象类
  3. public abstract class State {
  4.     // 扣除积分 - 50
  5.     public abstract void deductMoney();
  6.     // 是否抽中奖品
  7.     public abstract boolean raffle();
  8.     // 发放奖品
  9.     public abstract  void dispensePrize();
  10. }
  11. [NoRaffleState.java]
  12. // 不能抽奖的状态
  13. public class NoRaffleState extends State {
  14.      // 初始化时传入活动引用，扣除积分后改变其状态
  15.     RaffleActivity activity;
  17.     public NoRaffleState(RaffleActivity activity) {
  18.         this.activity = activity;
  19.     }
  21.     // 当前状态可以扣积分, 扣除后(假定扣除操作一定会成功),将状态设置成可以抽奖状态
  22.     @Override
  23.     public void deductMoney() {
  24.         System.out.println("扣除50积分成功，您可以抽奖了");
  25.         activity.setState(activity.getCanRaffleState());
  26.     }
  28.     // 当前状态不能抽奖
  29.     @Override
  30.     public boolean raffle() {
  31.         System.out.println("扣了积分才能抽奖喔！");
  32.         return false;
  33.     }
  35.     // 当前状态不能发奖品
  36.     @Override
  37.     public void dispensePrize() {
  38.         System.out.println("不能发放奖品");
  39.     }
  40. }
  41. [CanRaffleState.java]
  42. //可以抽奖的状态
  43. public class CanRaffleState extends State {
  44.     RaffleActivity activity;
  46.     public CanRaffleState(RaffleActivity activity) {
  47.         this.activity = activity;
  48.     }
  50.     //已经扣除了积分，不能再扣
  51.     @Override
  52.     public void deductMoney() {
  53.         System.out.println("已经扣取过了积分");
  54.     }
  56.     //可以抽奖, 抽完奖后，根据实际情况，改成新的状态
  57.     @Override
  58.     public boolean raffle() {
  59.         System.out.println("正在抽奖，请稍等！");
  60.         Random r = new Random();
  61.         int num = r.nextInt(10);//随机生成一个0-9之间的数
  62.         // 10%中奖机会
  63.         if(num == 0){
  64.             //中奖了：改变活动状态为发放奖品 context
  65.             activity.setState(activity.getDispenseState());
  66.             return true;
  67.         }else{
  68.             System.out.println("很遗憾没有抽中奖品！");
  69.             // 未抽中：改变状态为不能抽奖
  70.             activity.setState(activity.getNoRafflleState());
  71.             return false;
  72.         }
  73.     }
  75.     // 不能发放奖品
  76.     @Override
  77.     public void dispensePrize() {
  78.         System.out.println("没中奖，不能发放奖品");
  79.     }
  80. }
  81. [DispenseState.java]
  82. //发放奖品的状态
  83. public class DispenseState extends State {
  84.      // 初始化时传入活动引用，发放奖品后改变其状态
  85.     RaffleActivity activity;
  87.     public DispenseState(RaffleActivity activity) {
  88.         this.activity = activity;
  89.     }
  91.     @Override
  92.     public void deductMoney() {
  93.         System.out.println("不能扣除积分");
  94.     }
  96.     @Override
  97.     public boolean raffle() {
  98.         System.out.println("不能抽奖");
  99.         return false;
  100.     }
  102.     //发放奖品
  103.     @Override
  104.     public void dispensePrize() {
  105.         if(activity.getCount() > 0){
  106.             System.out.println("恭喜中奖了");
  107.             // 改变状态为不能抽奖
  108.             activity.setState(activity.getNoRafflleState());
  109.         }else{
  110.             System.out.println("很遗憾，奖品发送完了");
  111.             // 改变状态为“奖品领完”, 后面我们就不可以抽奖
  112.             activity.setState(activity.getDispensOutState());
  113.             //System.out.println("抽奖活动结束");
  114.             //System.exit(0);
  115.         }
  116.     }
  117. }
  118. [DispenseOutState.java]
  119. /**
  120.  * 奖品发放完毕的状态
  121.  * 说明，当我们activity 改变成 DispenseOutState， 抽奖活动结束，所有的活动都不能再进行
  122.  */
  123. public class DispenseOutState extends State {
  124.     RaffleActivity activity;// 初始化时传入活动引用
  126.     public DispenseOutState(RaffleActivity activity) {
  127.         this.activity = activity;
  128.     }
  129.     @Override
  130.     public void deductMoney() {
  131.         System.out.println("奖品发送完了，请下次再参加");
  132.     }
  134.     @Override
  135.     public boolean raffle() {
  136.         System.out.println("奖品发送完了，请下次再参加");
  137.         return false;
  138.     }
  140.     @Override
  141.     public void dispensePrize() {
  142.         System.out.println("奖品发送完了，请下次再参加");
  143.     }
  144. }
  145. [RaffleActivity.java]
  146. // 抽奖活动 
  147. public class RaffleActivity {
  148.     State state = null;//state 表示活动当前的状态，该状态是变化的
  149.     int count = 0;    // 奖品数量
  151.     // 四个属性，表示四种状态
  152.     State noRafflleState = new NoRaffleState(this);
  153.     State canRaffleState = new CanRaffleState(this);
  155.     State dispenseState =  new DispenseState(this);
  156.     State dispensOutState = new DispenseOutState(this);
  158.     //构造器
  159.     //1. 初始化当前的状态为 noRafflleState（即不能抽奖的状态）
  160.     //2. 初始化奖品的数量 
  161.     public RaffleActivity( int count) {
  162.         this.state = getNoRafflleState();
  163.         this.count = count;
  164.     }
  166.     //扣积分, 调用当前状态的 deductMoney
  167.     public void debuctMoney(){
  168.         state.deductMoney();
  169.     }
  171.     //抽奖 
  172.     public void raffle(){
  173.         // 如果当前的状态是抽奖成功
  174.         if(state.raffle()){
  175.             //领取奖品
  176.             state.dispensePrize();
  177.         }
  178.     }
  180.     public State getState() { return state; }
  181.     public void setState(State state) { this.state = state; }
  183.     //这里请大家注意，每领取一次奖品，count--
  184.     public int getCount() {
  185.         int curCount = count; 
  186.         count--;
  187.         return curCount;
  188.     }
  189.     public void setCount(int count) { this.count = count; }
  191.     public State getNoRafflleState() { return noRafflleState; }
  192.     public void setNoRafflleState(State noRafflleState) {
  193.         this.noRafflleState = noRafflleState;
  194.     }
  196.     public State getCanRaffleState() { return canRaffleState; }
  197.     public void setCanRaffleState(State canRaffleState) {
  198.         this.canRaffleState = canRaffleState;
  199.     }
  201.     public State getDispenseState() { return dispenseState; }
  202.     public void setDispenseState(State dispenseState) {
  203.         this.dispenseState = dispenseState;
  204.     }
  206.     public State getDispensOutState() { return dispensOutState; }
  207.     public void setDispensOutState(State dispensOutState) {
  208.         this.dispensOutState = dispensOutState;
  209.     }
  210. }
  211. [ClientTest.java]
  212. //状态模式测试类
  213. public class ClientTest {
  214.     public static void main(String[] args) {
  215.         // 创建活动对象，奖品有1个奖品
  216.         RaffleActivity activity = new RaffleActivity(1);
  218.         // 我们连续抽30次奖
  219.         for (int i = 0; i < 30; i++) {
  220.             System.out.println("------第" + (i + 1) + "次抽奖--------");
  221.             // 参加抽奖，第一步点击扣除积分
  222.             activity.debuctMoney();
  223.             // 第二步抽奖
  224.             activity.raffle();
  225.         }
  226.     }
  227. }

image.png

[State.java]
// 状态接口
public interface State {
    // 电审
    void checkEvent(Context context);
    // 电审失败
    void checkFailEvent(Context context);
    // 定价发布
    void makePriceEvent(Context context);
    // 接单
    void acceptOrderEvent(Context context);
    // 无人接单失效
    void notPeopleAcceptEvent(Context context);
    // 付款
    void payOrderEvent(Context context);
    //接单有人支付失效
    void orderFailureEvent(Context context);
    // 反馈
    void feedBackEvent(Context context);

    String getCurrentState();
}
[AbstractState.java]
public abstract class AbstractState implements State {
    protected static final RuntimeException EXCEPTION = new RuntimeException("操作流程不允许");

    //抽象类，默认实现了 State 接口的所有方法
    //该类的所有方法 在其子类(具体的状态类)中 可以有选择地进行重写

    @Override
    public void checkEvent(Context context) { throw EXCEPTION; }
    @Override
    public void checkFailEvent(Context context) { throw EXCEPTION; }
    @Override
    public void makePriceEvent(Context context) { throw EXCEPTION; }
    @Override
    public void acceptOrderEvent(Context context) { throw EXCEPTION; }
    @Override
    public void notPeopleAcceptEvent(Context context) { throw EXCEPTION; }
    @Override
    public void payOrderEvent(Context context) { throw EXCEPTION; }
    @Override
    public void orderFailureEvent(Context context) { throw EXCEPTION; }
    @Override
    public void feedBackEvent(Context context) { throw EXCEPTION; }
}
[AllState.java]
//各种具体状态类（有选择地重写）
class FeedBackState extends AbstractState {
    @Override
    public String getCurrentState() {
        return StateEnum.FEED_BACKED.getValue();
    }
}

class GenerateState extends AbstractState {
    @Override
    public void checkEvent(Context context) {
        context.setState(new ReviewState());
    }

    @Override
    public void checkFailEvent(Context context) {
        context.setState(new FeedBackState());
    }

    @Override
    public String getCurrentState() {
        return StateEnum.GENERATE.getValue();
    }
}

//未付款的状态
class NotPayState extends AbstractState {
    @Override
    public void payOrderEvent(Context context) {
        context.setState(new PaidState());
    }

    @Override
    public void feedBackEvent(Context context) {
        context.setState(new FeedBackState());
    }

    @Override
    public String getCurrentState() {return StateEnum.NOT_PAY.getValue();}
}

//已付款的状态
class PaidState extends AbstractState {
    @Override
    public void feedBackEvent(Context context) {
        context.setState(new FeedBackState());
    }
    @Override
    public String getCurrentState() { return StateEnum.PAID.getValue(); }
}

//发布状态
class PublishState extends AbstractState {
    @Override
    public void acceptOrderEvent(Context context) {
        //把当前状态设置为  NotPayState
        //至于应该变成哪个状态，由流程图来决定
        context.setState(new NotPayState());
    }

    @Override
    public void notPeopleAcceptEvent(Context context) {
        context.setState(new FeedBackState());
    }

    @Override
    public String getCurrentState() {
        return StateEnum.PUBLISHED.getValue();
    }
}

class ReviewState extends AbstractState {
    @Override
    public void makePriceEvent(Context context) {
        context.setState(new PublishState());
    }

    @Override
    public String getCurrentState() {
        return StateEnum.REVIEWED.getValue();
    }
}
[StateEnum.java]
//状态枚举类
public enum StateEnum {
    //订单生成
    GENERATE(1, "GENERATE"), 
   //已审核
    REVIEWED(2, "REVIEWED"), 
    //已发布
    PUBLISHED(3, "PUBLISHED"),
    //待付款
    NOT_PAY(4, "NOT_PAY"),
    //已付款
    PAID(5, "PAID"),
    //已完结
    FEED_BACKED(6, "FEED_BACKED");

    private int key;
    private String value;

    StateEnum(int key, String value) {
        this.key = key;
        this.value = value;
    }
    public int getKey() {return key;}
    public String getValue() {return value;}
}
[Context.java]
//环境上下文
public class Context extends AbstractState{
    //当前的状态 state, 根据我们的业务流程处理，不停的变化
    private State state;

  @Override
  public void checkEvent(Context context) {
      state.checkEvent(this);
      getCurrentState();
  }

  @Override
  public void checkFailEvent(Context context) {
      state.checkFailEvent(this);
      getCurrentState();
  }

  @Override
  public void makePriceEvent(Context context) {
      state.makePriceEvent(this);
      getCurrentState();
  }

  @Override
  public void acceptOrderEvent(Context context) {
      state.acceptOrderEvent(this);
      getCurrentState();
  }

  @Override
  public void notPeopleAcceptEvent(Context context) {
      state.notPeopleAcceptEvent(this);
      getCurrentState();
  }

  @Override
  public void payOrderEvent(Context context) {
      state.payOrderEvent(this);
      getCurrentState();
  }

  @Override
  public void orderFailureEvent(Context context) {
      state.orderFailureEvent(this);
      getCurrentState();
  }

  @Override
  public void feedBackEvent(Context context) {
      state.feedBackEvent(this);
      getCurrentState();
  }

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

  @Override
  public String getCurrentState() {
      System.out.println("当前状态 : " + state.getCurrentState());
      return state.getCurrentState();
  }
}
[ClientTest.java]
/**测试类*/
public class ClientTest {
    public static void main(String[] args) {
        //创建context 对象
        Context context = new Context();
        //将当前状态设置为 PublishState
        context.setState(new PublishState());
        System.out.println(context.getCurrentState());

//        //publish --> not pay
        context.acceptOrderEvent(context);
//        //not pay --> paid
        context.payOrderEvent(context);
//        // 失败, 检测失败时，会抛出异常
//        try {
//            context.checkFailEvent(context);
//            System.out.println("流程正常..");
//        } catch (Exception e) {
//            System.out.println(e.getMessage());
//        }
    }
}