Java设计模式之 [20] 行为型模式

简介

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

状态模式原理类图和说明

1.原理类图

原理类图

状态说明

1.Context 类为环境角色,用于维护 State 的实例
2.State 是一个接口,抽象状态角色,定义一个接口封装与Context的一个特点接口相关行为
3.ConcreteState 具有的状态角色,每个子类实现一个与Context的一个状态的相关的行为

案例演示 APP抽奖活动

APP抽奖活动

状态模式解决APP抽奖问题

1.需求再上图
2.思路分析和图解(类图)

定义出一个接口叫状态接口,每个状态都要实现它
接口有扣除积分方法,抽奖方法,发放奖品方法

类图分析

3.代码实现

public abstract class State {
    public abstract void deductMoney();
    public abstract boolean raffle();
    public abstract void dispensePrize();
}

public class CanRaffleState extends State {

    RaffleActivity activity;

    public CanRaffleState(RaffleActivity activity) {
        this.activity = activity;
    }

    @Override
    public void deductMoney() {
        System.out.println("已经扣取过了积分");
    }

    @Override
    public boolean raffle() {
        System.out.println("正在抽奖，请稍等！");
        Random r = new Random();
        int num = r.nextInt(10);
        // 10%中奖机会
        if (num == 0) {
            // 改变活动状态为发放奖品
            activity.setState(activity.getDispenseState());
            return true;
        } else {
            System.out.println("很遗憾没有抽中奖品！");
            // 改变状态为不能抽奖
            activity.setState(activity.getNoRafflleState());
            return false;
        }
    }

    @Override
    public void dispensePrize() {
        System.out.println("没中奖，不能发放奖品");
    }
}

public class DispenseOutState extends State {

    // 初始化时传入活动引用
    RaffleActivity activity;

    public DispenseOutState(RaffleActivity activity) {
        this.activity = activity;
    }

    @Override
    public void deductMoney() {
        System.out.println("奖品发送完了，请下次再参加");
    }

    @Override
    public boolean raffle() {
        System.out.println("奖品发送完了，请下次再参加");
        return false;
    }

    @Override
    public void dispensePrize() {
        System.out.println("奖品发送完了，请下次再参加");
    }
}

public class DispenseOutState extends State {

    // 初始化时传入活动引用
    RaffleActivity activity;

    public DispenseOutState(RaffleActivity activity) {
        this.activity = activity;
    }

    @Override
    public void deductMoney() {
        System.out.println("奖品发送完了，请下次再参加");
    }

    @Override
    public boolean raffle() {
        System.out.println("奖品发送完了，请下次再参加");
        return false;
    }

    @Override
    public void dispensePrize() {
        System.out.println("奖品发送完了，请下次再参加");
    }
}

public class RaffleActivity {

    State state = null;
    int count = 0;
    State noRafflleState = new NoRaffleState(this);
    State canRaffleState = new CanRaffleState(this);

    State dispenseState = new DispenseState(this);
    State dispensOutState = new DispenseOutState(this);

    public RaffleActivity(int count) {
        this.state = getNoRafflleState();
        this.count = count;
    }

    public void debuctMoney() {
        state.deductMoney();
    }

    public void raffle() {
        if (state.raffle()) {
            state.dispensePrize();
        }

    }

    public State getState() {
        return state;
    }

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

    public int getCount() {
        int curCount = count;
        count--;
        return curCount;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public State getNoRafflleState() {
        return noRafflleState;
    }

    public void setNoRafflleState(State noRafflleState) {
        this.noRafflleState = noRafflleState;
    }

    public State getCanRaffleState() {
        return canRaffleState;
    }

    public void setCanRaffleState(State canRaffleState) {
        this.canRaffleState = canRaffleState;
    }

    public State getDispenseState() {
        return dispenseState;
    }

    public void setDispenseState(State dispenseState) {
        this.dispenseState = dispenseState;
    }

    public State getDispensOutState() {
        return dispensOutState;
    }

    public void setDispensOutState(State dispensOutState) {
        this.dispensOutState = dispensOutState;
    }
}

public class NoRaffleState extends State {

     // 初始化时传入活动引用，扣除积分后改变其状态
   RaffleActivity activity;

   public NoRaffleState(RaffleActivity activity) {
       this.activity = activity;
   }

   @Override
   public void deductMoney() {
       System.out.println("扣除50积分成功，您可以抽奖了");
       activity.setState(activity.getCanRaffleState());
   }

   @Override
   public boolean raffle() {
       System.out.println("扣了积分才能抽奖喔！");
       return false;
   }

   @Override
   public void dispensePrize() {
       System.out.println("不能发放奖品");
   }
}

public class ClientTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 创建活动对象，奖品池有5个奖品
        RaffleActivity activity = new RaffleActivity(1);

        // 我们连续抽三次奖
        for (int i = 0; i < 10; i++) {
            System.out.println("--------第" + (i + 1) + "次抽奖----------");
            // 参加抽奖，第一步点击扣除积分
            activity.debuctMoney();

            // 第二步抽奖
            activity.raffle();
        }
    }

}

打印结果

--------第1次抽奖----------
扣除50积分成功，您可以抽奖了
正在抽奖，请稍等！
很遗憾没有抽中奖品！
--------第2次抽奖----------
扣除50积分成功，您可以抽奖了
正在抽奖，请稍等！
很遗憾没有抽中奖品！
--------第3次抽奖----------
扣除50积分成功，您可以抽奖了
正在抽奖，请稍等！
很遗憾没有抽中奖品！
--------第4次抽奖----------
扣除50积分成功，您可以抽奖了
正在抽奖，请稍等！
很遗憾没有抽中奖品！
--------第5次抽奖----------
扣除50积分成功，您可以抽奖了
正在抽奖，请稍等！
恭喜中奖了
--------第6次抽奖----------
扣除50积分成功，您可以抽奖了
正在抽奖，请稍等！
很遗憾没有抽中奖品！
--------第7次抽奖----------
扣除50积分成功，您可以抽奖了
正在抽奖，请稍等！
很遗憾没有抽中奖品！
--------第8次抽奖----------
扣除50积分成功，您可以抽奖了
正在抽奖，请稍等！
很遗憾没有抽中奖品！
--------第9次抽奖----------
扣除50积分成功，您可以抽奖了
正在抽奖，请稍等！
很遗憾，奖品发送完了
--------第10次抽奖----------
奖品发送完了，请下次再参加
奖品发送完了，请下次再参加

状态设计模式实际项目 - 借贷平台源码分析

1.借贷平台的订单,有审核 - 发布 - 抢单等等步骤.随着操作的不同,会改变订单的状态,项目中的这个模块就会用到状态模式
2.通常通过 if / else 判断订单的状态从而实现不同的逻辑

if (审核) {
    //审核逻辑
} else if(发布){
    //发布逻辑
}else {
    //接单逻辑
}

类图分析

类图分析

代码实现

public abstract class AbstractState implements State {

    protected static final RuntimeException EXCEPTION = new RuntimeException("操作流程不允许");

    @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;
    }
}

//环境上下文
public class Context extends AbstractState{
    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();
  }
}

//各种具体状态类
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) {
        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();
    }

}

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();
}

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;
    }
}

/**测试类*/
public class ClientTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Context context = new Context();
        context.setState(new PublishState());
        //然后可以根据操作变化状态.
        
        //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());
//      }
        
    }

}

测试

当前状态 : NOT_PAY
当前状态 : PAID

状态模式的注意事项和细节

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

Java设计模式之 [20] 行为型模式 - 状态模式

简介

状态模式原理类图和说明

状态说明

案例演示 APP抽奖活动

状态模式解决APP抽奖问题

状态设计模式实际项目 - 借贷平台源码分析

状态模式的注意事项和细节

你可能感兴趣的:(Java设计模式之 [20] 行为型模式 - 状态模式)

Java设计模式之 [20] 行为型模式 - 状态模式

简介

状态模式原理类图和说明

状态说明

案例演示 APP抽奖活动

状态模式解决APP抽奖问题

状态设计模式实际项目 - 借贷平台 源码分析

状态模式的注意事项和细节

你可能感兴趣的:(Java设计模式之 [20] 行为型模式 - 状态模式)

状态设计模式实际项目 - 借贷平台源码分析