学习笔记【23种设计模式-第二十一节：State Pattern 状态模式】

State Pattern 状态模式

简述

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

角色

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

例子

抽奖：有个State抽象类，有deduceMoney、raffle、dispensePrize方法。有NoRaffleState、CanReffleState、DispenseState、DispenseOutState类继承State。有一个Activity活动类关联它们。

State抽象类：

public abstract class State {
    public abstract void deductMoney();//扣除积分
    public abstract boolean raffle();//是否抽中奖品
    public abstract void dispensePrize();//发放奖品
}

NoRaffleState类：

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("不能发放奖品！");
    }
}

CanReffleState类：

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 random=new Random();
        int num=random.nextInt(10);
        if (num==0){
            activity.setState(activity.getDispenseState());
            return true;
        }else {
            System.out.println("很遗憾没有抽中奖品！");
            activity.setState(activity.getNoRaffleState());
            return false;
        }
    }

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

DispenseState类：

public class DispenseState extends State{
    RaffleActivity activity;

    public DispenseState(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() {
        if (activity.getCount()>0){
            System.out.println("恭喜中奖了！");
            activity.setState(activity.getNoRaffleState());
        }else {
            System.out.println("很遗憾，奖品发送完了！");
            activity.setState(activity.getDispenseOutState());
        }
    }
}

DispenseOutState类：

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("奖品发送完，请下次参加！");
    }
}

Activity类：

public class RaffleActivity {
    State state=null;
    int count=0;

    State noRaffleState=new NoRaffleState(this);
    State canRaffleState=new CanRaffleState(this);
    State dispenseState=new DispenseState(this);
    State dispenseOutState=new DispenseOutState(this);

    public RaffleActivity(int count) {
        state=getNoRaffleState();
        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 getNoRaffleState() {
        return noRaffleState;
    }

    public void setNoRaffleState(State noRaffleState) {
        this.noRaffleState = noRaffleState;
    }

    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 getDispenseOutState() {
        return dispenseOutState;
    }

    public void setDispenseOutState(State dispenseOutState) {
        this.dispenseOutState = dispenseOutState;
    }
}

Client主方法：

public class Client {
    public static void main(String[] args) {
        RaffleActivity activity=new RaffleActivity(1);

        for (int i=0;i<3;i++){
            System.out.println("--------------第"+(i+1)+"次抽奖------------");
            activity.debuctMoney();
            activity.raffle();
        }
    }
}

注意事项

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