設計模式 狀態模式 以自動售貨機爲例

轉載請標明出處：http://blog.csdn.net/lmj623565791/article/details/26350617

狀態模式給了我眼前一亮的感覺啊，值得學習~

先看定義：允許對象在內部狀態改變時改變它的行爲，對象看起來好像修改了它的類。定義又開始模糊了，理一下，當對象的內部狀態改變時，它的行爲跟隨狀態的改變而改變了，看起來好像重新初始化了一個類似的。

下面使用個例子來說明狀態模式的用法，現在有個自動售貨機的代碼需要我們來寫，狀態圖如下：

分析一個這個狀態圖：

a、包含4個狀態（我們使用4個int型常量來表示）

b、包含3個暴露在外的方法（投幣、退幣、轉動手柄）

c、我們需要處理每個狀態下，用戶都可以觸發這三個動作。

下面我們根據分析的結果，寫出代碼：

package com.zhy.pattern.status;

/**
 * 自動售貨機
 *
 * @author zhy
 *
 */
public class VendingMachine
{

    /**
     * 已投幣
     */
    private final static int HAS_MONEY = 0;
    /**
     * 未投幣
     */
    private final static int NO_MONEY = 1;
    /**
     * 售出商品
     */
    private final static int SOLD = 2;
    /**
     * 商品售罄
     */
    private final static int SOLD_OUT = 3;

    private int currentStatus = NO_MONEY;
    /**
     * 商品數量
     */
    private int count = 0;

    public VendingMachine(int count)
    {
        this.count = count;
        if (count > 0)
        {
            currentStatus = NO_MONEY;
        }
    }

    /**
     * 投入硬幣，任何狀態用戶都可能投幣
     */
    public void insertMoney()
    {
        switch (currentStatus)
        {
        case NO_MONEY:
            currentStatus = HAS_MONEY;
            System.out.println("成功投入硬幣");
            break;
        case HAS_MONEY:
            System.out.println("已經有硬幣，無需投幣");
            break;
        case SOLD:
            System.out.println("請稍等...");
            break;
        case SOLD_OUT:
            System.out.println("商品已經售罄，請勿投幣");
            break;

        }
    }

    /**
     * 退幣，任何狀態用戶都可能退幣
     */
    public void backMoney()
    {
        switch (currentStatus)
        {
        case NO_MONEY:
            System.out.println("您未投入硬幣");
            break;
        case HAS_MONEY:
            currentStatus = NO_MONEY;
            System.out.println("退幣成功");
            break;
        case SOLD:
            System.out.println("您已經買了糖果...");
            break;
        case SOLD_OUT:
            System.out.println("您未投幣...");
            break;
        }
    }

    /**
     * 轉動手柄購買,任何狀態用戶都可能轉動手柄
     */
    public void turnCrank()
    {
        switch (currentStatus)
        {
        case NO_MONEY:
            System.out.println("請先投入硬幣");
            break;
        case HAS_MONEY:
            System.out.println("正在出商品....");
            currentStatus = SOLD;
            dispense();
            break;
        case SOLD:
            System.out.println("連續轉動也沒用...");
            break;
        case SOLD_OUT:
            System.out.println("商品已經售罄");
            break;

        }
    }

    /**
     * 發放商品
     */
    private void dispense()
    {

        switch (currentStatus)
        {
        case NO_MONEY:
        case HAS_MONEY:
        case SOLD_OUT:
            throw new IllegalStateException("非法的狀態...");
        case SOLD:
            count--;
            System.out.println("發出商品...");
            if (count == 0)
            {
                System.out.println("商品售罄");
                currentStatus = SOLD_OUT;
            } else
            {
                currentStatus = NO_MONEY;
            }
            break;

        }

    }
}

針對用戶的每個動作，我們考慮了在任何狀態下發生，並做了一定處理。下面進行一些測試：

package com.zhy.pattern.status;

public class TestTra
{
    public static void main(String[] args)
    {
        VendingMachine machine = new VendingMachine(10);
        machine.insertMoney();
        machine.backMoney();

        System.out.println("-----------");

        machine.insertMoney();
        machine.turnCrank();

        System.out.println("----------壓力測試-----");
        machine.insertMoney();
        machine.insertMoney();
        machine.turnCrank();
        machine.turnCrank();
        machine.backMoney();
        machine.turnCrank();

    }
}

輸出結果：

成功投入硬幣
退幣成功
-----------
成功投入硬幣
正在出商品....
發出商品...
----------壓力測試-----
成功投入硬幣
已經有硬幣，無需投幣
正在出商品....
發出商品...
請先投入硬幣
您未投入硬幣
請先投入硬幣

感覺還是不錯的，基本實現了功能，但是有些事情是不可避免的，那就是需求的變化，現在爲了提升銷量，當用戶每次轉動手柄買商品的時候，有10%的機率贈送一瓶。

現在的狀態圖發生了變化，當用戶轉動手柄時，可能會達到一箇中獎的狀態：圖如下：

如果在我們剛寫的代碼上直接添加，則需要在每個動作的switch中添加判斷條件，且非常容易出錯。所以現在我們要考慮重新設計我們的代碼，我們考慮把每個狀態寫狀態類，負責實現在對應動作下的行爲，然後自動售貨機在不能的狀態間切換：

下面開始重構，我們現在有5種狀態，對應4個動作（投幣、退幣、轉動手柄、發出商品），下面首先定義一個狀態的超類型：

package com.zhy.pattern.status.b;

/**
 * 狀態的接口
 * @author zhy
 *
 */
public interface State
{
    /**
     * 放錢
     */
    public void insertMoney();
    /**
     * 退錢
     */
    public void backMoney();
    /**
     * 轉動曲柄
     */
    public void turnCrank();
    /**
     * 出商品
     */
    public void dispense();
}

然後分別是每個狀態的實現：

package com.zhy.pattern.status.b;

/**
 * 沒錢的狀態
 * @author zhy
 *
 */
public class NoMoneyState implements State
{

    private VendingMachine machine;

    public NoMoneyState(VendingMachine machine)
    {
        this.machine = machine;

    }

    @Override
    public void insertMoney()
    {
        System.out.println("投幣成功");
        machine.setState(machine.getHasMoneyState());
    }

    @Override
    public void backMoney()
    {
        System.out.println("您未投幣，想退錢？...");
    }

    @Override
    public void turnCrank()
    {
        System.out.println("您未投幣，想拿東西麼？...");
    }

    @Override
    public void dispense()
    {
        throw new IllegalStateException("非法狀態！");
    }

}

package com.zhy.pattern.status.b;

import java.util.Random;

/**
 * 已投入錢的狀態
 *
 * @author zhy
 *
 */
public class HasMoneyState implements State
{

    private VendingMachine machine;
    private Random random = new Random();

    public HasMoneyState(VendingMachine machine)
    {
        this.machine = machine;
    }

    @Override
    public void insertMoney()
    {
        System.out.println("您已經投過幣了，無需再投....");
    }

    @Override
    public void backMoney()
    {
        System.out.println("退幣成功");

        machine.setState(machine.getNoMoneyState());
    }

    @Override
    public void turnCrank()
    {
        System.out.println("你轉動了手柄");
        int winner = random.nextInt(10);
        if (winner == 0 && machine.getCount() > 1)
        {
            machine.setState(machine.getWinnerState());
        } else
        {
            machine.setState(machine.getSoldState());
        }
    }

    @Override
    public void dispense()
    {
        throw new IllegalStateException("非法狀態！");
    }

}

package com.zhy.pattern.status.b;

/**
 * 售罄的狀態
 *
 * @author zhy
 *
 */
public class SoldOutState implements State
{

    private VendingMachine machine;

    public SoldOutState(VendingMachine machine)
    {
        this.machine = machine;
    }

    @Override
    public void insertMoney()
    {
        System.out.println("投幣失敗，商品已售罄");
    }

    @Override
    public void backMoney()
    {
        System.out.println("您未投幣，想退錢麼？...");
    }

    @Override
    public void turnCrank()
    {
        System.out.println("商品售罄，轉動手柄也木有用");
    }

    @Override
    public void dispense()
    {
        throw new IllegalStateException("非法狀態！");
    }

}

package com.zhy.pattern.status.b;

/**
 * 準備出商品的狀態,該狀態下，不會有任何用戶的操作
 *
 * @author zhy
 *
 */
public class SoldState implements State
{

    private VendingMachine machine;

    public SoldState(VendingMachine machine)
    {
        this.machine = machine;
    }

    @Override
    public void insertMoney()
    {
        System.out.println("正在出貨，請勿投幣");
    }

    @Override
    public void backMoney()
    {
        System.out.println("正在出貨，沒有可退的錢");
    }

    @Override
    public void turnCrank()
    {
        System.out.println("正在出貨，請勿重複轉動手柄");
    }

    @Override
    public void dispense()
    {
        machine.dispense();
        if (machine.getCount() > 0)
        {
            machine.setState(machine.getNoMoneyState());
        } else
        {
            System.out.println("商品已經售罄");
            machine.setState(machine.getSoldOutState());
        }
    }
}

package com.zhy.pattern.status.b;

/**
 * 中獎的狀態，該狀態下不會有任何用戶的操作
 *
 * @author zhy
 *
 */
public class WinnerState implements State
{

    private VendingMachine machine;

    public WinnerState(VendingMachine machine)
    {
        this.machine = machine;
    }

    @Override
    public void insertMoney()
    {
        throw new IllegalStateException("非法狀態");
    }

    @Override
    public void backMoney()
    {
        throw new IllegalStateException("非法狀態");
    }

    @Override
    public void turnCrank()
    {
        throw new IllegalStateException("非法狀態");
    }

    @Override
    public void dispense()
    {
        System.out.println("你中獎了，恭喜你，將得到2件商品");
        machine.dispense();

        if (machine.getCount() == 0)
        {
            System.out.println("商品已經售罄");
            machine.setState(machine.getSoldOutState());
        } else
        {
            machine.dispense();
            if (machine.getCount() > 0)
            {
                machine.setState(machine.getNoMoneyState());
            } else
            {
                System.out.println("商品已經售罄");
                machine.setState(machine.getSoldOutState());
            }

        }

    }

}

最後是自動售貨機的代碼：

package com.zhy.pattern.status.b;

/**
 * 自動售貨機
 *
 * @author zhy
 *
 */
public class VendingMachine
{
    private State noMoneyState;
    private State hasMoneyState;
    private State soldState;
    private State soldOutState;
    private State winnerState ;

    private int count = 0;
    private State currentState = noMoneyState;

    public VendingMachine(int count)
    {
        noMoneyState = new NoMoneyState(this);
        hasMoneyState = new HasMoneyState(this);
        soldState = new SoldState(this);
        soldOutState = new SoldOutState(this);
        winnerState = new WinnerState(this);

        if (count > 0)
        {
            this.count = count;
            currentState = noMoneyState;
        }
    }

    public void insertMoney()
    {
        currentState.insertMoney();
    }

    public void backMoney()
    {
        currentState.backMoney();
    }

    public void turnCrank()
    {
        currentState.turnCrank();
        if (currentState == soldState || currentState == winnerState)
            currentState.dispense();
    }

    public void dispense()
    {
        System.out.println("發出一件商品...");
        if (count != 0)
        {
            count -= 1;
        }
    }

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

    //getter setter omitted ...

}

可以看到，我們現在把每個狀態對應於動作的行爲局部化到了狀態自己的類中實現，不僅增加了擴展性而且使代碼的閱讀性大幅度的提高。以後再添加狀態，只需要針對新添加的狀態的實現類，並在自動售貨機中添加此狀態即可。

下面進行一些測試：

package com.zhy.pattern.status.b;

public class Test
{
    public static void main(String[] args)
    {
        VendingMachine machine = new VendingMachine(10);
        machine.insertMoney();
        machine.backMoney();

        System.out.println("----我要中獎----");

        machine.insertMoney();
        machine.turnCrank();
        machine.insertMoney();
        machine.turnCrank();
        machine.insertMoney();
        machine.turnCrank();
        machine.insertMoney();
        machine.turnCrank();
        machine.insertMoney();
        machine.turnCrank();
        machine.insertMoney();
        machine.turnCrank();
        machine.insertMoney();
        machine.turnCrank();

        System.out.println("-------壓力測試------");

        machine.insertMoney();
        machine.backMoney();
        machine.backMoney();
        machine.turnCrank();// 無效操作
        machine.turnCrank();// 無效操作
        machine.backMoney();

    }
}

輸出結果：

投幣成功
退幣成功
----我要中獎----
投幣成功
你轉動了手柄
發出一件商品...
投幣成功
你轉動了手柄
發出一件商品...
投幣成功
你轉動了手柄
發出一件商品...
投幣成功
你轉動了手柄
發出一件商品...
投幣成功
你轉動了手柄
發出一件商品...
投幣成功
你轉動了手柄
發出一件商品...
投幣成功
你轉動了手柄
你中獎了，恭喜你，將得到2件商品
發出一件商品...
發出一件商品...
-------壓力測試------
投幣成功
退幣成功
您未投幣，想退錢？...
您未投幣，想拿東西麼？...
您未投幣，想拿東西麼？...
您未投幣，想退錢？...

恭喜你，又學會了一個設計模式，狀態模式。最後看下狀態模式的類圖