设计模式（11）---状态模式

状态模式 State （行为型模式）

 

1.概述

 

状态模式：允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。

例如：有一个账户，当余额大于等于0时，为正常状态，可以存款，取款；当-2000<=余额<0时，为透支状态，可以存款取款以及计算利息；当余额<-2000时，为限制状态，不能取款，可以存款，计算利息。根据账户余额的不同，状态会改变，每个状态的行为也会变化。

 

2.结构图

3.代码

/*
 * 账户类   也是Context  环境类
 */
public class AccountContext {

    private State state ;//持有一个对抽象状态对象的引用
    private double account = 0D ;//账户初始金额
    
    public AccountContext() {
        this.state = new NormalState(this);
    }

    public void setState(State state) {
        this.state = state;
    }
    public double getAccount() {
        return account;
    }
    public void setAccount(double account) {
        this.account = account;
    }
    
    public void deposit(double account){
        System.out.println("存款"+ account);
        state.deposit(account);
        System.out.println("现在余额为"+this.getAccount());
        System.out.println("现在状态为" + this.state.getClass().getName());
        System.out.println("----------------------");
    }
    
    public void withdraw(double account){
        System.out.println("取款款"+ account);
        state.withdraw(account);
        System.out.println("现在余额为"+this.getAccount());
        System.out.println("现在状态为" + this.state.getClass().getName());
        System.out.println("----------------------");
    }
    
    public void computeInterest(){
        
        state.computeInterest(); 
    }  
    

}

public abstract class State {

    protected AccountContext acc ;
    public abstract void deposit(double account) ;//存钱
    public abstract void withdraw(double account) ;//取钱
    public abstract void computeInterest();  //计算利息
    public abstract void stateCheck();//状态装换

}

/*
 * 正常状态
 */
public class NormalState extends State {

    public NormalState(AccountContext account) {
        this.acc = account ;
    }
    
    public NormalState(State state) {  
        this.acc = state.acc;  
    } 

    @Override
    public void deposit(double account) {
        acc.setAccount(acc.getAccount() + account);
        stateCheck();

    }

    @Override
    public void withdraw(double account) {
        acc.setAccount(acc.getAccount() - account);
        stateCheck();

    }

    @Override
    public void computeInterest() {
        System.out.println("不用计算利息");

    }

    @Override
    public void stateCheck() {
        if (acc.getAccount() > -2000 && acc.getAccount() <= 0) {  
            acc.setState(new OverdraftState(this));  
        }  
        else if (acc.getAccount() <= -2000) {  
            acc.setState(new RestrictedState(this));  
        }  
           

    }

}

/*
 * 透支状态
 */
public class OverdraftState extends State {

    public OverdraftState(AccountContext account) {
        this.acc = account ;
    }
    
    public OverdraftState(State state) {  
        this.acc = state.acc;  
    } 

    @Override
    public void deposit(double account) {
        acc.setAccount(acc.getAccount() + account);
        stateCheck();

    }

    @Override
    public void withdraw(double account) {
        acc.setAccount(acc.getAccount() - account);
        stateCheck();

    }

    @Override
    public void computeInterest() {
        System.out.println("计算利息");

    }

    //状态转换  
    public void stateCheck() {  
        if (acc.getAccount() > 0) {  
            acc.setState(new NormalState(this));  
        }  
        else if (acc.getAccount() <= -2000) {  
            acc.setState(new RestrictedState(this));  
        }  
     
    }  

}

/*
 * 限制状态
 */
public class RestrictedState extends State {

    public RestrictedState(AccountContext account) {
        this.acc = account ;
    }
    
    public RestrictedState(State state) {  
        this.acc = state.acc;  
    } 

    @Override
    public void deposit(double account) {
        acc.setAccount(acc.getAccount() + account);
        stateCheck();

    }

    @Override
    public void withdraw(double account) {
        System.out.println("无法取钱");

    }

    @Override
    public void computeInterest() {
        System.out.println("计算利息");

    }

    @Override
    public void stateCheck() {
        if(acc.getAccount() > 0) {  
            acc.setState(new NormalState(this));  
        }  
        else if(acc.getAccount() > -2000) {  
            acc.setState(new OverdraftState(this));  
        }  

    }

}

public class Test {

    public static void main(String[] args) {
        AccountContext context = new AccountContext();
        context.deposit(1000);
        context.withdraw(2000);
        context.withdraw(2000);
        context.withdraw(2000);
        context.computeInterest();
        

    }

}

状态模式将一个对象的状态从该对象中分离出来，封装到专门的状态类中，使得对象状态可以灵活变化，对于客户端而言，无须关心对象状态的转换以及对象所处的当前状态，无论对于何种状态的对象，客户端都可以一致处理。

 

4.共享状态

在有些情况下，多个环境对象可能需要共享同一个状态，如果希望在系统中实现多个环境对象共享一个或多个状态对象，那么需要将这些状态对象定义为环境类的静态成员对象。

例如有多个开关对象，他们共同使用一个开状态，和一个关状态，当一个开关从开状态到关状态，其他开关都会变为关状态。

 

5.使用环境类实现状态转换

例如：玩射击游戏时，使用狙击枪，点击一下右键，切换到放大瞄准状态，再点一下右键，切换到更大倍率的放大，再点一下则回到正常状态。

这里可以将状态切换方法写在Context里，用if....else根据当前状态，切换到下一个状态，每点一下右键则调用这个方法。

缺点是如果需要增加新的方法，需要修改Context类。

 

6.优点

（1）将与特定状态相关的行为局部化，并将不同状态的行为分割开来。如果需要增加新的状态，只要再添加新的状态类就可以了。注入一个不同的状态对象即可使环境对象拥有不同的行为。

（2） 封装了状态的转换规则，在状态模式中可以将状态的转换代码封装在环境类或者具体状态类中，可以对状态转换代码进行集中管理，而不是分散在一个个业务方法中。

（3）消除大量条件语句。

 

7.适用场景

（1）当一个对象的行为取决于它的状态，并且需要在运行时刻根据它的状态来改变它的行为。

 

 

参考：http://blog.csdn.net/lovelion/article/details/8522982