设计模式——状态模式

设计模式——状态模式

本篇博文通过尚硅谷韩老师《设计模式》课程所做，在此非常感谢！

基本介绍

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

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

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

UML

问题引入

请编写一个能完成APP 抽奖活动的程序，具体要求如下:

• 每参加一次这个活动要扣除用户一定的积分，中奖概率是20%；
• 奖品数量固定，抽完就不能抽奖；
• 活动有四个状态: 可以抽奖、不能抽奖、发放奖品和奖品领完

编码实现

首先，编写一个所有状态类的基类State，如下：

package edu.hebeu.state;

/**
 * 抽象的状态基类
 * @author 13651
 *
 */
public abstract class State {
	
	/**
	 * 扣除积分50
	 */
	public abstract void deductIntegral();
	
	/**
	 * 判断是否抽中奖品
	 * @return
	 */
	public abstract boolean raffle();
	
	/**
	 * 发放奖品
	 */
	public abstract void dispensePrize();
	
}

再分别编写具体的状态类，如下：

package edu.hebeu.state;

import java.util.Random;

import edu.hebeu.RaffleActivityContext;

/**
 * 该类是能够抽奖的状态
 * @author 13651
 *
 */
public class CanRaffleState extends State{
	
	private RaffleActivityContext activity;
	
	public CanRaffleState(RaffleActivityContext activity) {
		this.activity = activity;
	}

	/**
	 * 能够抽奖的状态下，是不能重复扣除积分的
	 */
	@Override
	public void deductIntegral() {
		System.out.println("不能重复扣取积分，请先抽奖！");
	}

	/**
	 * 能够抽奖的状态下，是可以进行抽奖以决定能否中奖
	 */
	@Override
	public boolean raffle() {
		System.out.println("正在抽奖...");
		Random r = new Random();
		int a = r.nextInt(10); // 抽取一个从[0, 10)范围内的随机整数
		if(a < 2) { // 如果随机数是小于2(十分之二的概率)，表示中奖！
			System.out.println("恭喜您已被奖品砸中！！！");
			activity.setState(activity.getDispenseState());
			return true;
		}
		System.out.println("很遗憾没有抽中~~~");
		activity.setState(activity.getNoRafflleState());
		return false;
	}

	/**
	 * 能够抽奖的状态下，是不能发放奖品的
	 */
	@Override
	public void dispensePrize() {
		System.out.println("您还未抽奖，没有奖品可以发放");
	}
	
}

package edu.hebeu.state;

import edu.hebeu.RaffleActivityContext;

/**
 * 该类是发放奖品的状态
 * @author 13651
 *
 */
public class DispenseState extends State{
	
	private RaffleActivityContext activity;
	
	public DispenseState(RaffleActivityContext activity) {
		this.activity = activity;
	}

	/**
	 * 发放奖品状态下，是不能扣除积分的
	 */
	@Override
	public void deductIntegral() {
		System.out.println("发放奖品中，不能扣除积分");
	}

	/**
	 * 发放奖品状态下，是不能抽奖的
	 */
	@Override
	public boolean raffle() {
		System.out.println("发放奖品中，不能进行抽奖");
		return false;
	}

	/**
	 * 发放奖品状态下，可以进行发放奖品
	 */
	@Override
	public void dispensePrize() {
		if(activity.getPrizeCount() <= 1) { // 如果还有1个或1个以下奖品
			System.out.println("奖品已下发");
			activity.setState(activity.getDispenseOutState()); // 将状态改成奖品发送完的状态，不能继续抽奖
			return;
		}
		// 程序执行到此，说明奖品还剩不止一个(2个或2个以上)
		System.out.println("奖品已下发");
		activity.setState(activity.getNoRafflleState()); // 将状态修改为最开始状态(不能抽奖状态)
	}
	
}

package edu.hebeu.state;

import edu.hebeu.RaffleActivityContext;

/**
 * 该类是奖品发送完的状态，即活动结束，此时不会进行扣除积分等一系列活动
 * @author 13651
 *
 */
public class DispenseOutState extends State{

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

	/**
	 * 奖品发送完，是不能扣除积分的
	 */
	@Override
	public void deductIntegral() {
		System.out.println("没有奖品了，欢迎下次参加");
	}

	@Override
	public boolean raffle() {
		System.out.println("没有奖品了，欢迎下次参加");
		return false;
	}

	@Override
	public void dispensePrize() {
		System.out.println("没有奖品了，欢迎下次参加");
	}

}

package edu.hebeu.state;

import edu.hebeu.RaffleActivityContext;

/**
 * 该类是不能抽奖的状态
 * @author 13651
 *
 */
public class NoRaffleState extends State{
	
	/**
	 * 初始化该程序时因为默认的是不可抽奖的状态(NoRaffleState)，当扣除积分后会变成可抽奖的状态，所以要使用该类型调用改变
	 */
	private RaffleActivityContext activity;
	
	public NoRaffleState(RaffleActivityContext activity) {
		this.activity = activity;
	}

	/**
	 * 不能抽奖的状态下，是可以扣除积分的，之后才能变成可抽奖的状态
	 */
	@Override
	public void deductIntegral() {
		System.out.println("已扣除积分50，您可以抽奖了");
		activity.setState(activity.getCanRaffleState()); // 此时将状态变成可抽奖的状态
	}

	/**
	 * 不能抽奖的状态下，是不能抽奖来决定是否中奖的
	 */
	@Override
	public boolean raffle() {
		System.out.println("未扣除积分，不能抽奖！");
		return false;
	}

	/**
	 * 不能抽奖的状态下，是不能发放奖品的
	 */
	@Override
	public void dispensePrize() {
		System.out.println("未扣除积分，不能发放奖品！");
	}
	
}

编写能够通过业务逻辑调度各种状态的类RaffleActivityContext，如下：

package edu.hebeu;

import edu.hebeu.state.CanRaffleState;
import edu.hebeu.state.DispenseOutState;
import edu.hebeu.state.DispenseState;
import edu.hebeu.state.NoRaffleState;
import edu.hebeu.state.State;

/**
 * 抽奖活动
 * @author Administrator
 *
 */
public class RaffleActivityContext {

	// state 表示活动当前的状态，是会随着变化的
    private State state = null;
    // 奖品数量
    private int count = 0;
    
    // 四个属性，表示四种状态
    State noRafflleState = new NoRaffleState(this);
    State canRaffleState = new CanRaffleState(this);
    
    State dispenseState =   new DispenseState(this);
    State dispenseOutState = new DispenseOutState(this);

    /*构造器
     * 1. 初始化当前的状态为 noRafflleState（即不能抽奖的状态）
     * 2. 初始化奖品的数量 
     */
    public RaffleActivityContext( int count) {
        this.state = getNoRafflleState();
        this.count = count;
    }

    /**
     * 扣分, 调用当前状态的 deductMoney
     */
    public void debuctMoney(){
        state.deductIntegral();
    }

    /**
     * 抽奖 
     */
    public void raffle(){
    	// 如果当前的状态是抽奖成功
        if(state.raffle()){
        	//领取奖品
            state.dispensePrize();
        }

    }

    public State getState() {
        return state;
    }

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

    // 每领取一次奖品，count--
    public int getPrizeCount() {
    	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 getDispenseOutState() {
        return dispenseOutState;
    }

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

测试类的编写，如下：

package edu.hebeu;

import java.util.Scanner;

/**
 * 状态模式测试类
 * @author Administrator
 *
 */
public class ClientTest {

	// 创建活动对象，奖品有3个奖品
    private static RaffleActivityContext ACTIVITY = new RaffleActivityContext(3);
    
	private static final Scanner SCANNER = new Scanner(System.in);
	private static boolean IS_CONTINUE = true;
	
	public static void main(String[] args) {
		do {
			System.out.print("您要进行几次抽奖："); int count = SCANNER.nextInt();
			raffle(count);
			System.out.print("继续？true/false"); IS_CONTINUE = SCANNER.nextBoolean();
		} while(IS_CONTINUE);
		SCANNER.close();
	}
	
	/**
	 * 进行抽奖的方法
	 * @param count 抽奖的次数
	 */
	private static void raffle(int count) {
		// 我们连续抽30次奖
        for (int i = 0; i < count; i++) {
            System.out.println("--------第" + (i + 1) + "次抽奖----------");
            // 参加抽奖，第一步点击扣除积分
            ACTIVITY.debuctMoney();

            // 第二步抽奖
            ACTIVITY.raffle();
            
            try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
        }
	}

}

测试