请编写程序完成APP抽奖活动 具
体要求如下:
1) 假如每参加一次这个活动要扣除用户50积分，中奖概率是10%
2) 奖品数量固定，抽完就不能抽奖
3) 活动有四个状态: 可以抽奖、不能抽奖、发放奖品和奖品领完

image.png

状态模式

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

image.png
Context 类为环境橘色，用于维护State实例，这个实例定义当前状态
State 是抽象状态角色，它定义一个接口封装于Context的一个特定接口相关行为
ConcreteState 具体的状态角色，每一个子类实现一个于Context的一个状态相关的行为

image.png

  1. /**
  2.  * 状态抽象类
  3.  * @author Administrator
  4.  *
  5.  */
  6. public abstract class State {
  9.     // 扣除积分 - 50
  10.     public abstract void deductMoney();
  12.     // 是否抽中奖品
  13.     public abstract boolean raffle();
  15.     // 发放奖品
  16.     public abstract  void dispensePrize();
  18. }
  22. /**
  23.  * 不能抽奖状态
  24.  * @author Administrator
  25.  *
  26.  */
  27. public class NoRaffleState extends State {
  29.      // 初始化时传入活动引用，扣除积分后改变其状态
  30.     RaffleActivity activity;
  32.     public NoRaffleState(RaffleActivity activity) {
  33.         this.activity = activity;
  34.     }
  36.     // 当前状态可以扣积分 , 扣除后，将状态设置成可以抽奖状态
  37.     @Override
  38.     public void deductMoney() {
  39.         System.out.println("扣除50积分成功，您可以抽奖了");
  40.         activity.setState(activity.getCanRaffleState());
  41.     }
  43.     // 当前状态不能抽奖
  44.     @Override
  45.     public boolean raffle() {
  46.         System.out.println("扣了积分才能抽奖喔！");
  47.         return false;
  48.     }
  50.     // 当前状态不能发奖品
  51.     @Override
  52.     public void dispensePrize() {
  53.         System.out.println("不能发放奖品");
  54.     }
  55. }
  58. /**
  59.  * 发放奖品的状态
  60.  * @author Administrator
  61.  *
  62.  */
  63. public class DispenseState extends State {
  65.      // 初始化时传入活动引用，发放奖品后改变其状态
  66.     RaffleActivity activity;
  68.     public DispenseState(RaffleActivity activity) {
  69.         this.activity = activity;
  70.     }
  72.     //
  74.     @Override
  75.     public void deductMoney() {
  76.         System.out.println("不能扣除积分");
  77.     }
  79.     @Override
  80.     public boolean raffle() {
  81.         System.out.println("不能抽奖");
  82.         return false;
  83.     }
  85.     //发放奖品
  86.     @Override
  87.     public void dispensePrize() {
  88.         if(activity.getCount() > 0){
  89.             System.out.println("恭喜中奖了");
  90.             // 改变状态为不能抽奖
  91.             activity.setState(activity.getNoRafflleState());
  92.         }else{
  93.             System.out.println("很遗憾，奖品发送完了");
  94.             // 改变状态为奖品发送完毕, 后面我们就不可以抽奖
  95.             activity.setState(activity.getDispensOutState());
  96.             //System.out.println("抽奖活动结束");
  97.             //System.exit(0);
  98.         }
  100.     }
  101. }
  104. /**
  105.  * 奖品发放完毕状态
  106.  * 说明，当我们activity 改变成 DispenseOutState， 抽奖活动结束
  107.  * @author Administrator
  108.  *
  109.  */
  110. public class DispenseOutState extends State {
  112.     // 初始化时传入活动引用
  113.     RaffleActivity activity;
  115.     public DispenseOutState(RaffleActivity activity) {
  116.         this.activity = activity;
  117.     }
  118.     @Override
  119.     public void deductMoney() {
  120.         System.out.println("奖品发送完了，请下次再参加");
  121.     }
  123.     @Override
  124.     public boolean raffle() {
  125.         System.out.println("奖品发送完了，请下次再参加");
  126.         return false;
  127.     }
  129.     @Override
  130.     public void dispensePrize() {
  131.         System.out.println("奖品发送完了，请下次再参加");
  132.     }
  133. }
  136. /**
  137.  * 可以抽奖的状态
  138.  * @author Administrator
  139.  *
  140.  */
  141. public class CanRaffleState extends State {
  143.     RaffleActivity activity;
  145.     public CanRaffleState(RaffleActivity activity) {
  146.         this.activity = activity;
  147.     }
  149.     //已经扣除了积分，不能再扣
  150.     @Override
  151.     public void deductMoney() {
  152.         System.out.println("已经扣取过了积分");
  153.     }
  155.     //可以抽奖, 抽完奖后，根据实际情况，改成新的状态
  156.     @Override
  157.     public boolean raffle() {
  158.         System.out.println("正在抽奖，请稍等！");
  159.         Random r = new Random();
  160.         int num = r.nextInt(10);
  161.         // 10%中奖机会
  162.         if(num == 0){
  163.             // 改变活动状态为发放奖品 context
  164.             activity.setState(activity.getDispenseState());
  165.             return true;
  166.         }else{
  167.             System.out.println("很遗憾没有抽中奖品！");
  168.             // 改变状态为不能抽奖
  169.             activity.setState(activity.getNoRafflleState());
  170.             return false;
  171.         }
  172.     }
  174.     // 不能发放奖品
  175.     @Override
  176.     public void dispensePrize() {
  177.         System.out.println("没中奖，不能发放奖品");
  178.     }
  179. }
  1. /**
  2.  * 抽奖活动 //
  3.  * 
  4.  * @author Administrator
  5.  *
  6.  */
  7. public class RaffleActivity {
  9.     // state 表示活动当前的状态，是变化
  10.     State state = null;
  11.     // 奖品数量
  12.     int count = 0;
  14.     // 四个属性，表示四种状态
  15.     State noRafflleState = new NoRaffleState(this);
  16.     State canRaffleState = new CanRaffleState(this);
  18.     State dispenseState =   new DispenseState(this);
  19.     State dispensOutState = new DispenseOutState(this);
  21.     //构造器
  22.     //1. 初始化当前的状态为 noRafflleState（即不能抽奖的状态）
  23.     //2. 初始化奖品的数量 
  24.     public RaffleActivity( int count) {
  25.         this.state = getNoRafflleState();
  26.         this.count = count;
  27.     }
  29.     //扣分, 调用当前状态的 deductMoney
  30.     public void debuctMoney(){
  31.         state.deductMoney();
  32.     }
  34.     //抽奖 
  35.     public void raffle(){
  36.         // 如果当前的状态是抽奖成功
  37.         if(state.raffle()){
  38.             //领取奖品
  39.             state.dispensePrize();
  40.         }
  42.     }
  44.     public State getState() {
  45.         return state;
  46.     }
  48.     public void setState(State state) {
  49.         this.state = state;
  50.     }
  52.     //这里请大家注意，每领取一次奖品，count--
  53.     public int getCount() {
  54.         int curCount = count; 
  55.         count--;
  56.         return curCount;
  57.     }
  59.     public void setCount(int count) {
  60.         this.count = count;
  61.     }
  63.     public State getNoRafflleState() {
  64.         return noRafflleState;
  65.     }
  67.     public void setNoRafflleState(State noRafflleState) {
  68.         this.noRafflleState = noRafflleState;
  69.     }
  71.     public State getCanRaffleState() {
  72.         return canRaffleState;
  73.     }
  75.     public void setCanRaffleState(State canRaffleState) {
  76.         this.canRaffleState = canRaffleState;
  77.     }
  79.     public State getDispenseState() {
  80.         return dispenseState;
  81.     }
  83.     public void setDispenseState(State dispenseState) {
  84.         this.dispenseState = dispenseState;
  85.     }
  87.     public State getDispensOutState() {
  88.         return dispensOutState;
  89.     }
  91.     public void setDispensOutState(State dispensOutState) {
  92.         this.dispensOutState = dispensOutState;
  93.     }
  94. }
  1. public static void main(String[] args) {
  2.         // TODO Auto-generated method stub
  3.         // 创建活动对象，奖品有1个奖品
  4.         RaffleActivity activity = new RaffleActivity(1);
  6.         // 我们连续抽300次奖
  7.         for (int i = 0; i < 30; i++) {
  8.             System.out.println("--------第" + (i + 1) + "次抽奖----------");
  9.             // 参加抽奖，第一步点击扣除积分
  10.             activity.debuctMoney();
  12.             // 第二步抽奖
  13.             activity.raffle();
  14.         }
  15.     }

订单问题 案例

image.png

image.png

image.png

  1. /**
  2.  * 状态接口
  3.  * @author Administrator
  4.  *
  5.  */
  6. public interface State {
  8.     /**
  9.      * 电审
  10.      */
  11.     void checkEvent(Context context);
  13.     /**
  14.      * 电审失败
  15.      */
  16.     void checkFailEvent(Context context);
  18.     /**
  19.      * 定价发布
  20.      */
  21.     void makePriceEvent(Context context);
  23.     /**
  24.      * 接单
  25.      */
  26.     void acceptOrderEvent(Context context);
  28.     /**
  29.      * 无人接单失效
  30.      */
  31.     void notPeopleAcceptEvent(Context context);
  33.     /**
  34.      * 付款
  35.      */
  36.     void payOrderEvent(Context context);
  38.     /**
  39.      * 接单有人支付失效
  40.      */
  41.     void orderFailureEvent(Context context);
  43.     /**
  44.      * 反馈
  45.      */
  46.     void feedBackEvent(Context context);
  49.     String getCurrentState();
  50. }
  53. public abstract class AbstractState implements State {
  55.     protected static final RuntimeException EXCEPTION = new RuntimeException("操作流程不允许");
  57.     //抽象类，默认实现了 State 接口的所有方法
  58.     //该类的所有方法，其子类(具体的状态类)，可以有选择的进行重写
  60.     @Override
  61.     public void checkEvent(Context context) {
  62.         throw EXCEPTION;
  63.     }
  65.     @Override
  66.     public void checkFailEvent(Context context) {
  67.         throw EXCEPTION;
  68.     }
  70.     @Override
  71.     public void makePriceEvent(Context context) {
  72.         throw EXCEPTION;
  73.     }
  75.     @Override
  76.     public void acceptOrderEvent(Context context) {
  77.         throw EXCEPTION;
  78.     }
  80.     @Override
  81.     public void notPeopleAcceptEvent(Context context) {
  82.         throw EXCEPTION;
  83.     }
  85.     @Override
  86.     public void payOrderEvent(Context context) {
  87.         throw EXCEPTION;
  88.     }
  90.     @Override
  91.     public void orderFailureEvent(Context context) {
  92.         throw EXCEPTION;
  93.     }
  95.     @Override
  96.     public void feedBackEvent(Context context) {
  97.         throw EXCEPTION;
  98.     }
  99. }
  1. /**
  2.  * 状态枚举类
  3.  * @author Administrator
  4.  *
  5.  */
  6. public enum StateEnum {
  8.      //订单生成
  9.     GENERATE(1, "GENERATE"),
  11.     //已审核
  12.     REVIEWED(2, "REVIEWED"),
  14.     //已发布
  15.     PUBLISHED(3, "PUBLISHED"),
  17.     //待付款
  18.     NOT_PAY(4, "NOT_PAY"),
  20.     //已付款
  21.     PAID(5, "PAID"),
  23.     //已完结
  24.     FEED_BACKED(6, "FEED_BACKED");
  26.     private int key;
  27.     private String value;
  29.     StateEnum(int key, String value) {
  30.         this.key = key;
  31.         this.value = value;
  32.     }
  33.     public int getKey() {return key;}
  34.     public String getValue() {return value;}
  35. }
  1. //各种具体状态类
  2. class FeedBackState extends AbstractState {
  4.     @Override
  5.     public String getCurrentState() {
  6.         return StateEnum.FEED_BACKED.getValue();
  7.     }
  8. }
  10. class GenerateState extends AbstractState {
  12.     @Override
  13.     public void checkEvent(Context context) {
  14.         context.setState(new ReviewState());
  15.     }
  17.     @Override
  18.     public void checkFailEvent(Context context) {
  19.         context.setState(new FeedBackState());
  20.     }
  22.     @Override
  23.     public String getCurrentState() {
  24.         return StateEnum.GENERATE.getValue();
  25.     }
  26. }
  28. class NotPayState extends AbstractState {
  30.     @Override
  31.     public void payOrderEvent(Context context) {
  32.         context.setState(new PaidState());
  33.     }
  35.     @Override
  36.     public void feedBackEvent(Context context) {
  37.         context.setState(new FeedBackState());
  38.     }
  40.     @Override
  41.     public String getCurrentState() {
  42.         return StateEnum.NOT_PAY.getValue();
  43.     }
  44. }
  46. class PaidState extends AbstractState {
  48.     @Override
  49.     public void feedBackEvent(Context context) {
  50.         context.setState(new FeedBackState());
  51.     }
  53.     @Override
  54.     public String getCurrentState() {
  55.         return StateEnum.PAID.getValue();
  56.     }
  57. }
  59. class PublishState extends AbstractState {
  61.     @Override
  62.     public void acceptOrderEvent(Context context) {
  63.         //把当前状态设置为  NotPayState。。。
  64.         //至于应该变成哪个状态，有流程图来决定
  65.         context.setState(new NotPayState());
  66.     }
  68.     @Override
  69.     public void notPeopleAcceptEvent(Context context) {
  70.         context.setState(new FeedBackState());
  71.     }
  73.     @Override
  74.     public String getCurrentState() {
  75.         return StateEnum.PUBLISHED.getValue();
  76.     }
  77. }
  79. class ReviewState extends AbstractState {
  81.     @Override
  82.     public void makePriceEvent(Context context) {
  83.         context.setState(new PublishState());
  84.     }
  86.     @Override
  87.     public String getCurrentState() {
  88.         return StateEnum.REVIEWED.getValue();
  89.     }
  91. }
//环境上下文
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();
    }
}


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //创建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) {
//            // TODO: handle exception
//            System.out.println(e.getMessage());
//        }

    }

注意事项

状态模式的注意事项和细节1) 代码有很强的可读性。状态模式将每个状态的行为封装到对应的一个类中
2) 方便维护。将容易产生问题的if-else语句删除了，如果把每个状态的行为都放到一
个类中，每次调用方法时都要判断当前是什么状态，不但会产出很多if-else语句，
而且容易出错
3) 符合“开闭原则”。容易增删状态
4) 会产生很多类。每个状态都要一个对应的类，当状态过多时会产生很多类，加大维
护难度
5) 应用场景：当一个事件或者对象有很多种状态，状态之间会相互转换，对不同的状
态要求有不同的行为的时候，可以考虑使用状态模式