状态模式

一. 定义

        允许对象在内部状态改变的时改变它的行为，对象看起来好像修改了它的类。

二. 模式起源

三. 原则

四. UML图

五. 代码

5.1 自动饮料售货机类

package model.state;

/**
 * 自动饮料售货机类
 */
public class DrinkMachine {

    private State noMoneyState;
    private State hasMoneyState;
    private State sellState;
    private State soldOutState;

    /**
     * 初始化一个状态  默认是没有饮料状态
     */
    private State state = soldOutState;

    /**
     * 饮料的数量 默认为0
     */
    private Integer count = 0;

    /**
     * 构造函数中维护了所有状态的实例
     *
     * @param drinkCount
     */
    public DrinkMachine(Integer drinkCount) {
        this.noMoneyState = new NoMoneyState(this);
        this.hasMoneyState = new HasMoneyState(this);
        this.sellState = new SellState(this);
        this.soldOutState = new SoldOutState(this);
        this.count = drinkCount;
        if (count > 0) {
            state = noMoneyState;
        }
    }

    public void insertMoney() {
        this.state.insertMoney();
    }

    public void returnMoney() {
        this.state.returnMoney();
    }

    public void turnCrank() {
        this.state.turnCrank();
        this.state.sell();
    }

    /**
     * 设置不同的状态
     *
     * @param state
     */
    public void setState(State state) {
        this.state = state;
    }

    public void releaseDrink() {
        System.out.println("the drink has been given you...");
        if (count != 0) {
            count = count - 1;
        }
    }

    public Integer getCount() {
        return count;
    }

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

    public State getNoMoneyState() {
        return noMoneyState;
    }

    public void setNoMoneyState(State noMoneyState) {
        this.noMoneyState = noMoneyState;
    }

    public State getHasMoneyState() {
        return hasMoneyState;
    }

    public void setHasMoneyState(State hasMoneyState) {
        this.hasMoneyState = hasMoneyState;
    }

    public State getSellState() {
        return sellState;
    }

    public void setSellState(State sellState) {
        this.sellState = sellState;
    }

    public State getSoldOutState() {
        return soldOutState;
    }

    public void setSoldOutState(State soldOutState) {
        this.soldOutState = soldOutState;
    }

    public State getState() {
        return state;
    }


}

5.2 状态接口

package model.state;

/**
 * 状态接口
 */
public interface State {

    /**
     * 投入硬币
     */
    public abstract void insertMoney();

    /**
     * 退还硬币
     */
    public abstract void returnMoney();

    /**
     * 转动曲柄
     */
    public abstract void turnCrank();

    /**
     * 售出饮料
     */
    public abstract void sell();

}

5.3 无硬币状态类

package model.state;

/**
 * 无硬币状态类
 */
public class NoMoneyState implements State {

    // 状态类里面维护了一个(上下文类)饮料机类
    private DrinkMachine drinkMachine;

    public NoMoneyState(DrinkMachine drinkMachine) {
        this.drinkMachine = drinkMachine;
    }

    @Override
    public void insertMoney() {
        System.out.println("you has inserted a coin...");
        this.drinkMachine.setState(this.drinkMachine.getHasMoneyState());
    }

    @Override
    public void returnMoney() {
        System.out.println("you has not inserted a coin...");
    }

    @Override
    public void turnCrank() {
        System.out.println("you turned the crank, but there is no coin in the machine...");
    }

    @Override
    public void sell() {
        System.out.println("you must insert a coin...");
    }
}

5.4 有硬币状态类

package model.state;

/**
 * 有硬币状态
 */
public class HasMoneyState implements State {

    // 状态类里面维护了一个(上下文类)饮料机类
    private DrinkMachine drinkMachine;
    public HasMoneyState(DrinkMachine drinkMachine) {
        this.drinkMachine = drinkMachine;
    }

    @Override
    public void insertMoney() {
        System.out.println("you can not insert another coin...");
    }

    @Override
    public void returnMoney() {
        System.out.println("the coin has been returned...");
        this.drinkMachine.setState(this.drinkMachine.getNoMoneyState());
    }

    @Override
    public void turnCrank() {
        System.out.println("you turned the crank, the machine is ready to sell a drink...");
        this.drinkMachine.setState(this.drinkMachine.getSellState());
    }

    @Override
    public void sell() {
        System.out.println("error operate...");
    }
}

5.5 售出状态类

package model.state;

/**
 * 售出状态类
 */
public class SellState implements State {

    // 状态类里面维护了一个(上下文类)饮料机类
    private DrinkMachine drinkMachine;
    public SellState(DrinkMachine drinkMachine) {
        this.drinkMachine = drinkMachine;
    }

    @Override
    public void insertMoney() {
        System.out.println("waiting... there is a coin in the machine...");
    }

    @Override
    public void returnMoney() {
        System.out.println("sorry, you has turned the crank...");
    }

    @Override
    public void turnCrank() {
        System.out.println("turning the crank twice does not get you another drink...");
    }

    @Override
    public void sell() {
        this.drinkMachine.releaseDrink();
        if(this.drinkMachine.getCount() > 0) {
            this.drinkMachine.setState(this.drinkMachine.getNoMoneyState());
        } else {
            System.out.println("the drink has been sold out...");
            this.drinkMachine.setState(this.drinkMachine.getSoldOutState());
        }

    }
}

5.6 售光状态类

package model.state;

/**
 * 饮料售光状态类
 */
public class SoldOutState implements State {

    // 状态类里面维护了一个(上下文类)饮料机类
    private DrinkMachine drinkMachine;
    public SoldOutState(DrinkMachine drinkMachine) {
        this.drinkMachine = drinkMachine;
    }

    @Override
    public void insertMoney() {
        System.out.println("you can not insert a coin, the drink has been sold out...");
    }

    @Override
    public void returnMoney() {
        System.out.println("you can not return a coin, you do not insert a coin...");
    }

    @Override
    public void turnCrank() {
        System.out.println("you turned the crank, but there is no drink in the machine...");
    }

    @Override
    public void sell() {
        System.out.println("error operate...");
    }
}

5.7 测试类

package model.state;

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

    public static void main(String[] args) {

        DrinkMachine drinkMachine = new DrinkMachine(3);

        System.out.println("投入硬币，转动曲柄...");
        drinkMachine.insertMoney();
        drinkMachine.turnCrank();
        System.out.println("the machine has drink :" + drinkMachine.getCount());

        System.out.println("投入硬币,退还硬币...");
        drinkMachine.insertMoney();
        drinkMachine.returnMoney();
        System.out.println("the machine has drink :" + drinkMachine.getCount());

    }

}

5.8 结果

投入硬币，转动曲柄...
you has inserted a coin...
you turned the crank, the machine is ready to sell a drink...
the drink has been given you...
the machine has drink :2
投入硬币,退还硬币...
you has inserted a coin...
the coin has been returned...
the machine has drink :2

六. 感悟