状态模式

1.状态模式：改变对象内部的状态控制，当动作被调用，被委托到当前的状态；          ------ 状态在游走，客户不了解

   策略模式：产生可以互换的算法控制；使用组合引用不同的状态来造成改变的假象； ------ 定制组合，客户定义

2.代码

C++

//state c++
#include <iostream>
using namespace std;

class State{
public:
    virtual void next() = 0; 
};

class Alaskan{
public:
    Alaskan(){}
    void setState(State * p){
        m_pState = p;
    }
    void nextState(){
        m_pState->next();
    }
public:
    State  * eatState;
    State  * sleepState;
    State  * playState;
private:
    State * m_pState;
};

class EatState : public State{
public:
    EatState(Alaskan *p) : m_p(p){}
    void next(){
        cout<<"sleeping..."<<endl;
        m_p->setState(m_p->sleepState);
    }
private:
    Alaskan *m_p;
};

class SleepState : public State{
public:
    SleepState(Alaskan *p) : m_p(p){}
    void next(){
        cout<<"play..."<<endl;
        m_p->setState(m_p->playState);
    }
private:
    Alaskan *m_p;
};

class PlayState : public State{
public:
    PlayState(Alaskan *p) : m_p(p){}
    void next(){
        cout<<"eating..."<<endl;
        m_p->setState(m_p->eatState);
    }
private:
    Alaskan *m_p;
};

int main(){
    Alaskan * alaskanDog   = new Alaskan();
    alaskanDog->eatState   = new EatState(alaskanDog);
    alaskanDog->sleepState = new SleepState(alaskanDog);
    alaskanDog->playState  = new PlayState(alaskanDog);
    
    cout<<"Alaskan is sleeping... "<<endl;
    alaskanDog->setState(alaskanDog->sleepState);
    
    cout<<"1.Alaskan Next: ";
    alaskanDog->nextState();
    
    cout<<"2.Alaskan Next: ";
    alaskanDog->nextState();
    
    cout<<"3.Alaskan Next: ";
    alaskanDog->nextState();
    
    return 0;
}

Java:

//state java
class GumballMachine{
    State soldOutState;
    State noQuarterState;
    State hasQuarterState;
    State soldState;
    
    State state = soldOutState;
    int count = 0;
    public GumballMachine(int numberGumballs){
        soldOutState    = new SoldOutState(this);
        noQuarterState  = new NoQuarterState(this);
        hasQuarterState = new HasQuarterState(this);
        soldState       = new SoldState(this);
        
        this.count = numberGumballs;
        if(numberGumballs > 0){
            state = noQuarterState;
        }else{
            state = soldOutState;
        }
    }
    
    public void insertQuarter(){
        state.insertQuarter();
    }
    public void ejectQuarter(){
        state.ejectQuarter();
    }
    public void turnCrank(){
        state.turnCrank();
        state.dispense();
    }    
    void releaseBall(){
        System.out.println("A gumball comes rolling out of the slot");
        if(count != 0){
            count = count -1;
        }
    }
    //change state
    void setState(State state){
        this.state = state;
    }
    public State getState(){
        return this.state;
    }
    public State getSoldOutState(){
        return soldOutState;
    }
    public State getNoQuarterState(){
        return noQuarterState;
    }
    public State getHasQuarterStete(){
        return hasQuarterState;
    }
    public State getSoldState(){
        return soldState;
    }
    public int getCount(){
        return count;
    }
    void refill(int count){
        this.count += count;
        System.out.println("Refill: " + count);
        state.refill();        
    }
    public String toString(){
        StringBuffer result = new StringBuffer();
        result.append("\nInventory number: " + count + "\n");
        result.append("state: " + state + "\n");
        return result.toString();
    }
}

//State
interface State{
    public void insertQuarter();
    public void ejectQuarter();
    public void turnCrank();
    public void dispense();
    public void refill();
}

class SoldOutState implements State{
    GumballMachine gumballMachine;
    public SoldOutState(GumballMachine gumballMachine){
        this.gumballMachine = gumballMachine;
    }
    public void insertQuarter(){
        System.out.println("can`n do it no gumball");
    }
    public void ejectQuarter(){
        System.out.println("can`n do it no gumball");
    }
    public void turnCrank(){
        System.out.println("can`n do it no gumball");
    }    
    public void dispense(){
        System.out.println("can`n do it no gumball");
    }    
    public String toString(){
        return "sold out";
    }
    public void refill(){
        gumballMachine.setState(gumballMachine.getNoQuarterState());
    }
}

class NoQuarterState implements State{
    GumballMachine gumballMachine;
    public NoQuarterState(GumballMachine gumballMachine){
        this.gumballMachine = gumballMachine;
    }
    public void insertQuarter(){
        System.out.println("You inserted a quarter");
        gumballMachine.setState(gumballMachine.getHasQuarterStete());
    }
    public void ejectQuarter(){
        System.out.println("You haven`t nserted a quarter");
    }
    public void turnCrank(){
        System.out.println("there is no quarter");
    }
    public void dispense(){
        System.out.println("You need to pay first");
    }
    public String toString(){
        return "waiting for quarter";
    }
    public void refill(){}
}

class HasQuarterState implements State{
    GumballMachine gumballMachine;
    public HasQuarterState(GumballMachine gumballMachine){
        this.gumballMachine = gumballMachine;
    }
    public void insertQuarter(){
        System.out.println("You can`t insert another quarter");
    }
    public void ejectQuarter(){
        System.out.println("Quarter returned");
        gumballMachine.setState(gumballMachine.getNoQuarterState());
    }
    public void turnCrank(){
        System.out.println("your turn...");
        gumballMachine.setState(gumballMachine.getSoldState());
    }
    public void dispense(){
        System.out.println("No gumball dispense");
    }
    public String toString(){
        return "waiting for turn of crank";
    }
    public void refill(){}
}

class SoldState implements State{
    GumballMachine gumballMachine;
    public SoldState(GumballMachine gumballMachine){
        this.gumballMachine = gumballMachine;
    }
    public void insertQuarter(){
        System.out.println("can`n do it");
    }
    public void ejectQuarter(){
        System.out.println("can`n do it");
    }
    public void turnCrank(){
        System.out.println("can`n do it");
    }    
    public void dispense(){
        gumballMachine.releaseBall();
        if(gumballMachine.getCount()>0)
            gumballMachine.setState(gumballMachine.getNoQuarterState());
        else
            gumballMachine.setState(gumballMachine.getSoldOutState());
    }
    public String toString(){
        return "sold State";
    }
    public void refill(){}
}

class gumballMachineTest{
    public static void main(String[] args){
        GumballMachine machine = new GumballMachine(2);
        System.out.println(machine);
        
        System.out.println("1>");
        machine.insertQuarter();
        machine.turnCrank();
        
        System.out.println("\n2>");
        machine.insertQuarter();
        machine.turnCrank();
        
        System.out.println("\n3>");
        machine.insertQuarter();
        
        System.out.println("\nRefill>");
        machine.refill(3);
        
        System.out.println("\n4>");
        machine.insertQuarter();
        machine.turnCrank();
    }
}

 3.其他：

Alaskan 在 State 前实现，函数Alaskan::nextState()的实现要放到State后面，在Alaskan类中仅声明该函数，可编过；

前置声明class State;后可以定义该类型指针，但实例化还不可。