行為型：九. 狀態模式-有解無憂

狀態模式是什么

狀態模式是一種行為設計模式，讓你能在一個物件的內部狀態變化時改變其行為，使其看上去就像改變了自身所屬的類一樣，

為什么要用狀態模式

如果物件需要根據自身當前狀態進行不同行為，同時狀態的數量非常多且與狀態相關的代碼會頻繁變更的話，可使用狀態模式，相似狀態和基于條件的狀態機轉換中存在許多重復代碼時，可使用狀態模式，

狀態模式怎么實作

這里用自動售歡訓舉例，自動售歡訓有四種狀態(有商品,商品已請求,收到紙幣,無商品)，而行為(選擇商品，增加商品，插入紙幣，出貨)會根據狀態的變化而變化，例如如果狀態為無商品時，不能選擇商品；而有商品時才可以選擇商品，

state.go

package state

type state interface {
	addItem(int) error           // 添加商品
	requestItem() error          // 選擇商品
	insertMoney(money int) error // 付錢
	dispenseItem() error         // 提供商品
}

has_item_state.go

package state

import "fmt"

// 有商品狀態
type hasItemState struct {
	vendingMachine *vendingMachine
}

func (i *hasItemState) requestItem() error {
	if i.vendingMachine.itemCount == 0 {
		i.vendingMachine.setState(i.vendingMachine.noItem)
		return fmt.Errorf("沒有庫存")
	}
	fmt.Printf("選擇商品\n")
	i.vendingMachine.setState(i.vendingMachine.itemRequested)
	return nil
}

func (i *hasItemState) addItem(count int) error {
	fmt.Printf("%d 增加商品數量：\n", count)
	i.vendingMachine.incrementItemCount(count)
	return nil
}

func (i *hasItemState) insertMoney(money int) error {
	return fmt.Errorf("請先選擇商品")
}
func (i *hasItemState) dispenseItem() error {
	return fmt.Errorf("請先選擇商品")
}

has_money_state.go

package state

import "fmt"

// 收到紙幣
type hasMoneyState struct {
	vendingMachine *vendingMachine
}

func (i *hasMoneyState) requestItem() error {
	return fmt.Errorf("正在出貨，請等待")
}

func (i *hasMoneyState) addItem(count int) error {
	return fmt.Errorf("正在出貨，請等待")
}

func (i *hasMoneyState) insertMoney(money int) error {
	return fmt.Errorf("正在出貨，請等待")
}
func (i *hasMoneyState) dispenseItem() error {
	fmt.Println("正在出貨")
	i.vendingMachine.itemCount = i.vendingMachine.itemCount - 1
	if i.vendingMachine.itemCount == 0 {
		i.vendingMachine.setState(i.vendingMachine.noItem)
	} else {
		i.vendingMachine.setState(i.vendingMachine.hasItem)
	}
	return nil
}

item_requested_state.go

package state

import (
	"errors"
	"fmt"
)

// 商品已選擇狀態
type itemRequestedState struct {
	vendingMachine *vendingMachine
}

func (i *itemRequestedState) requestItem() error {
	return fmt.Errorf("商品已經選擇")
}

func (i *itemRequestedState) addItem(count int) error {
	return fmt.Errorf("正在售賣中，不能添加商品")
}

func (i *itemRequestedState) insertMoney(money int) error {
	if money < i.vendingMachine.itemPrice {
		fmt.Errorf("插入金額不足，請插入： %d", i.vendingMachine.itemPrice)
		return errors.New("插入金額不足")
	}
	fmt.Println("正在出貨")
	i.vendingMachine.setState(i.vendingMachine.hasMoney)
	return nil
}
func (i *itemRequestedState) dispenseItem() error {
	return fmt.Errorf("請先投幣")
}

no_item_state.go

package state

import "fmt"


// 無商品狀態
type noItemState struct {
	vendingMachine *vendingMachine
}

func (i *noItemState) requestItem() error {
	return fmt.Errorf("庫存不足")
}

func (i *noItemState) addItem(count int) error {
	i.vendingMachine.incrementItemCount(count)
	i.vendingMachine.setState(i.vendingMachine.hasItem)
	return nil
}

func (i *noItemState) insertMoney(money int) error {
	return fmt.Errorf("庫存不足")
}
func (i *noItemState) dispenseItem() error {
	return fmt.Errorf("庫存不足")
}

vending_machine.go

package state

import "fmt"

type vendingMachine struct {
	hasItem       state // 有商品
	itemRequested state // 商品已請求
	hasMoney      state // 收到紙幣
	noItem        state // 無商品

	currentState state // 當前狀態

	itemCount int // 商品價格
	itemPrice int // 商品庫存
}

func newVendingMachine(itemCount, itemPrice int) *vendingMachine {
	v := &vendingMachine{
		itemCount: itemCount,
		itemPrice: itemPrice,
	}
	hasItemState := &hasItemState{  
		vendingMachine: v,
	}
	itemRequestedState := &itemRequestedState{
		vendingMachine: v,
	}
	hasMoneyState := &hasMoneyState{
		vendingMachine: v,
	}
	noItemState := &noItemState{
		vendingMachine: v,
	}

	v.setState(hasItemState)
	v.hasItem = hasItemState
	v.itemRequested = itemRequestedState
	v.hasMoney = hasMoneyState
	v.noItem = noItemState
	return v
}

func (v *vendingMachine) requestItem() error {
	return v.currentState.requestItem()
}

func (v *vendingMachine) addItem(count int) error {
	return v.currentState.addItem(count)
}

func (v *vendingMachine) insertMoney(money int) error {
	return v.currentState.insertMoney(money)
}

func (v *vendingMachine) dispenseItem() error {
	return v.currentState.dispenseItem()
}

func (v *vendingMachine) setState(s state) {
	v.currentState = s
}

func (v *vendingMachine) incrementItemCount(count int) {
	fmt.Printf("庫存增加 %d 個商品\n", count)
	v.itemCount = v.itemCount + count
}

example.go

package state

import (
	"log"
)

func Example() {
	vendingMachine := newVendingMachine(1, 10)
	err := vendingMachine.requestItem() 
	if err != nil {
		log.Fatalf(err.Error())
	}
	
	err = vendingMachine.insertMoney(10)
	if err != nil {
		log.Fatalf(err.Error())
	}
	
	err = vendingMachine.dispenseItem()
	if err != nil {
		log.Fatalf(err.Error())
	}
	
	err = vendingMachine.addItem(2)
	if err != nil {
		log.Fatalf(err.Error())
	}
	
	err = vendingMachine.requestItem()
	if err != nil {
		log.Fatalf(err.Error())
	}
	
	err = vendingMachine.insertMoney(10)
	if err != nil {
		log.Fatalf(err.Error())
	}
	
	err = vendingMachine.dispenseItem()
	if err != nil {
		log.Fatalf(err.Error())
	}
}

//運行結果：
//選擇商品
//正在出貨
//正在出貨
//庫存增加 2 個商品
//選擇商品
//正在出貨
//正在出貨

優點

單一職責原則，將與特定狀態相關的代碼放在單獨的類中，
開閉原則，無需修改已有狀態類和背景關系就能引入新狀態，

缺點

狀態模式的使用必然會增加系統的類與物件的個數，
狀態模式的結構與實作都較為復雜，如果使用不當會導致程式結構和代碼的混亂，

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/463541.html

標籤：設計模式

上一篇：sqlite3OperationalError：靠近“m”：語法錯誤

下一篇：行為型：九. 狀態模式