状态模式

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

状态模式将一个类的实例对象的状态封装成为独立的类，并把类的动作委托到代表当前状态的类去实现。这样当对象的状态发生改变时，这个对象就会呈现不同的动作表现。

类图：

糖果售卖机具有四种状态：没有25分钱状态，有25分钱状态，售出糖果状态，糖果售罄状态
在糖果售卖机处于不同的状态下，糖果售卖机的动作表现不同。如在没有25分钱的状态下，投入25分钱的动作是合法的，在售出糖果的状态下，投入25分钱的动作是不合法的。
这时，就要更具售卖机对象处于不同的状态，来输出不同的语句。

状态接口  State接口

/**
 * 这是糖果售卖机的状态接口  State
 * 糖果售卖机具有四种状态：没有25分钱状态，有25分钱状态，售出糖果状态，糖果售罄状态
 * 糖果售卖机 提供三个接口 给顾客调用  ：投入25分钱，退出25分钱，转动曲柄(相当于确认购买)
 * 糖果售卖机 有一个接口 给自己调用：发放糖果 
 * @author wly
 *
 */
public interface State {
     /**
      * 投入25分钱  的方法
      */
     public  void  insertQuarter();
     /**
      * 退出25分钱  的方法     
      */
     public  void  ejectQuarter();
     /**
      * 转动曲柄 确认购买 的方法
      */
     public  void  turnCrank();
     /**
      * 发放糖果 的方法
      */
     public void dispense();
}

 糖果售卖机  GumballMachine类

/**
 * 这是糖果售卖机   GumballMachine类
 * @author wly
 *
 */
public class GumballMachine {
    //声明一个变量，来引用 没有25分钱状态对象
    private   NoQuarterState  noQuarterState;
    //声明一个变量，来引用 有25分钱状态对象
    private   HasQuarterState hasQuarterState;
    //声明一个变量，来引用 售卖状态对象
    private   SoldState       soldState;
    //声明一个变量，来引用 售罄状态对象
    private   SoldOutState    soldOutState;
    //声明一个变量 ，  来表示 当前糖果售卖机 是处于 哪一种状态   新的糖果机处于售罄状态（因为没有糖果）
    private   State   state = soldOutState;
    //声明一个变量 ， 表示 糖果的剩余数量
    private   int count;
    /**
     * 糖果售卖机的构造器      
     * @param count
     */
    public GumballMachine(int count)
    {
        //为糖果售卖机 创建四种状态对象   并把糖果售卖机的对象引用传给状态对象
        this.noQuarterState  =  new NoQuarterState(this);
        this.hasQuarterState =  new HasQuarterState(this);
        this.soldState       =  new SoldState(this);
        this.soldOutState    =  new SoldOutState(this);
        this.count  = count;
        //如果 传入的糖果数量大于0  让糖果售卖机  到 没有25分钱的状态
        if(count > 0 )
        {
            this.setState(noQuarterState);
        }
    }
    /**
     * 用来设置糖果售卖机当前状态对象的 setter方法
     * @param state
     */
    public void setState(State state)
    {
        this.state = state;
    }
    /**
     * 发出一个糖果  ，糖果剩余数量减1
     */
    public void realseBall()
    {
        if(count > 0)
        {
            count--;
        }
        System.out.println("一个糖果已经发出...还剩"+count+"个糖果");
    }
    //放入25分钱 的方法 让已经持有糖果机对象的状态对象去处理
    public void insertQuarter() {
        state.insertQuarter();
    }
    //退回25分钱 的方法 让已经持有糖果机对象的状态对象去处理
    public void ejectQuarter() {
        state.ejectQuarter();
     }
    //转动曲柄 的方法 让已经持有糖果机对象的状态对象去处理
    public void turnCrank() {
        state.turnCrank();
        //现在糖果机处于售卖状态  会自动调用dispense()方法 来发放糖果
        state.dispense();
    }
    //以下是 四种状态对象 和  糖果剩余数量对象的  getter方法 和 setter方法
    public NoQuarterState getNoQuarterState() {
        return noQuarterState;
    }
    public void setNoQuarterState(NoQuarterState noQuarterState) {
        this.noQuarterState = noQuarterState;
    }
    public HasQuarterState getHasQuarterState() {
        return hasQuarterState;
    }
    public void setHasQuarterState(HasQuarterState hasQuarterState) {
        this.hasQuarterState = hasQuarterState;
    }
    public SoldState getSoldState() {
        return soldState;
    }
    public void setSoldState(SoldState soldState) {
        this.soldState = soldState;
    }
    public SoldOutState getSoldOutState() {
        return soldOutState;
    }
    public void setSoldOutState(SoldOutState soldOutState) {
        this.soldOutState = soldOutState;
    }
    public int getCount() {
        return count;
    }
    public void setCount(int count) {
        this.count = count;
    }
    
} 

 没有25分钱状态 NoQuarterState类

/**
 * 这是没有25分钱状态  NoQuarterState类 
 * 没有25分钱状态下  只有 放入钱的方法可用  可以引起状态改变
 * @author wly
 *
 */
public class NoQuarterState implements State {
    //声明一个变量 ，来引用糖果售卖机对象
    private GumballMachine  gm;
    public NoQuarterState(GumballMachine gm)
    {
        this.gm = gm;
    }
    @Override
    public void insertQuarter() {
        System.out.println("你已经放入了25分钱...");
        //改变糖果售卖机的状态  到 有25分钱的状态
        gm.setState(gm.getHasQuarterState());
    }
    
    @Override
    public void ejectQuarter() {
        System.out.println("你还没有放入钱，不能要求退钱...");
    }
    
    @Override
    public void turnCrank() {
        System.out.println("你还没有放入钱，不能转动曲柄...");
    }
    
    @Override
    public void dispense() {
       System.out.println("你还没有放入钱，不能发放糖果...");
    }

}

 有25分钱的状态 HasQuarterState类

/**
 * 这是有25分钱的状态   HasQuarterState类 
 * 在有25分钱的状态下  可以使用 退回钱的方法  从而让糖果售卖机的状态回到   没有25分钱状态
 * 可以使用 转动曲柄的方法  让糖果售卖机的状态前进到   售卖状态
 * @author wly
 *
 */
public class HasQuarterState implements State {
    //声明一个变量 ，来引用糖果售卖机对象
    private  GumballMachine  gm;
    public  HasQuarterState(GumballMachine gm)
    {
        this.gm = gm;
    }
    @Override
    public void insertQuarter() {
        System.out.println("你已经放入了钱，不能再放入钱...");
    }
    
    @Override
    public void ejectQuarter() {
        System.out.println("钱将退回给你...");
        //改变糖果售卖机的状态  到  没有25分钱的状态
        gm.setState(gm.getNoQuarterState());
    }
    
    @Override
    public void turnCrank() {
        System.out.println("转动曲柄...");
        //改变糖果售卖机的状态  到  售卖的状态
        gm.setState(gm.getSoldState());
    }
    
    @Override
    public void dispense() {
        System.out.println("糖果暂时不能发放...");
    }

}

 售卖的状态 SoldState类

/**
 * 这是售卖的状态   SoldState类 
 * 售卖状态的 糖果发放方法 调用之后   根据当前的糖果数量  来决定 到到哪个状态
 * @author wly
 *
 */
public class SoldState implements State {
    //声明一个变量 ，来引用糖果售卖机对象
    private GumballMachine  gm;
    public SoldState(GumballMachine gm)
    {
        this.gm = gm;
    }
     
    @Override
    public void insertQuarter() {
       System.out.println("请稍等，上一次的购买还在发放中，现在不能放入钱...");
    }
    
    @Override
    public void ejectQuarter() {
       System.out.println("你已经转动曲柄，确认购买了，不能退钱了...");
    }
    
    @Override
    public void turnCrank() {
       System.out.println("曲柄已经转动了，不能转动两次...");
    }
    
    @Override
    public void dispense() {
         System.out.println("发放糖果中...");
         //发放糖果的方法，糖果数量减1
         gm.realseBall();
         //如果糖果售卖机中的 糖果数量  大于0 糖果售卖机的状态 到 没有25分钱的状态
         if(gm.getCount() > 0)
         {
             gm.setState(gm.getNoQuarterState());
         }
         else  //如果糖果售卖机中的 糖果数量  小于等于0 糖果售卖机的状态 到 售罄状态 
         {
             System.out.println("糖果已经售罄...");
             gm.setState(gm.getSoldOutState());
         }
    }

}

糖果售罄状态   SoldOutState类

 1 /**
 2  * 这是糖果售罄状态   SoldOutState类
 3  * @author wly
 4  *
 5  */
 6 public class SoldOutState implements State{
 7     //声明一个变量 ，来引用糖果售卖机对象
 8     private GumballMachine  gm;
 9     public SoldOutState(GumballMachine gm)
10     {
11         this.gm = gm;
12     }
13     @Override
14     public void insertQuarter() {
15        System.out.println("糖果已经售罄，不能再放入钱...");
16     }
17     
18     @Override
19     public void ejectQuarter() {
20         System.out.println("糖果已经售罄，不能退回钱...");
21     }
22     
23     @Override
24     public void turnCrank() {
25         System.out.println("糖果已经售罄，不能转动曲柄...");
26     }
27     
28     @Override
29     public void dispense() {
30        System.out.println("糖果已经售罄，不能发放糖果...");
31     }
32 }

最后提供一个测试类：

public class TestClass {

    /**
     * @param args
     */
    public static void main(String[] args) {
         //创建一个糖果售卖机对象  ，并为这个糖果售卖机对象  放入5颗糖果
         //糖果售卖机  处于 没有25分钱状态
         GumballMachine gm = new GumballMachine(5);
         //放入25分钱  ， 糖果售卖机处于有25分钱状态
         gm.insertQuarter();
         //转动曲柄  ，糖果售卖机处于售卖状态 ，自动调用发放糖果方法，糖果售卖机 将处于没有25分钱状态
         gm.turnCrank();
         System.out.println("********************");
         //放入25分钱  ， 糖果售卖机处于有25分钱状态
         gm.insertQuarter();
         //退回25分钱 ，糖果售卖机处于没有25分钱状态
         gm.ejectQuarter();
         System.out.println("********************");
         gm.insertQuarter();
         gm.turnCrank();
         System.out.println("********************");
         gm.insertQuarter();
         gm.turnCrank();
         System.out.println("********************");
         gm.insertQuarter();
         gm.turnCrank();
         System.out.println("********************");
         //放入25分钱  ， 糖果售卖机处于有25分钱状态
         gm.insertQuarter();
         //转动曲柄  ，糖果售卖机处于售卖状态 ，自动调用发放糖果方法，糖果售卖机 中的糖果数为0，糖果售卖机将到糖果售罄状态
         gm.turnCrank();
         
    }
}

运行结果如下：