状态模式

1，状态模式的定义

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

2,uml图 顺序图

 

• Context:环境，也称上下文，通常用来定义客户感兴趣的接口，同时维护一个来具体处理当前状态的实例对象。
  
  
• State: 状态接口，用来封装与上下文的一个特定状态所对应的行为。
  
  
• ConcreteState: 具体实现状态的类，每个类实现一个跟上下文相关的状态的具体处理。

3,示例代码

 

/**
 * 封装与的一个特定状态相关的行为
 */
public interface State {
    public void handle(String sampleParameter);
}

public class ConcreteStateA implements State {

    @Override
    public void handle(String sampleParameter) {
    
    }

}


public class ConcreteStateB implements State {

    @Override
    public void handle(String sampleParameter) {

    }

}

public class Context {
    private State state;

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

    public void request(String sampleParameter) {
        state.handle(sampleParameter);
    }

}

4，实例代码

     考虑一个用户在线投票引用，要实现控制同一个用户只能投一票，如果一个用户反复投票，而且投票次数超过5次，则判定为恶意刷票，要取消该用户投票的资格，当然用户同时也要取消他所投的票；

      如果一个用户投的票次数超过8次，将进入黑名单，禁止在登录和使用系统

 

public interface VoteState {

    public void vote(String user,String voteItem,VoteManager voteManger);

}

/**
 * 正常投票
 */
public class NormalVoteState implements VoteState {

    @Override
    public void vote(String user, String voteItem, VoteManager voteManger) {
        // TODO Auto-generated method stub
        voteManger.getMapVote().put(user, voteItem);
        System.out.println("恭喜你投票成功");
    }

}


/**
 *重复投票
 */
public class RepeatVoteState implements VoteState {

    @Override
    public void vote(String user, String voteItem, VoteManager voteManger) {
        System.out.println("请不要重复投票");
    }

}


/**
 * 恶意投票
 */
public class SpiteVoteState implements VoteState {

    @Override
    public void vote(String user, String voteItem, VoteManager voteManger) {
        String s = voteManger.getMapVote().get(user);
        if(s != null) {
            voteManger.getMapVote().remove(user);
        }

        System.out.println(user +" 你有恶意刷票行为，取消"+ voteItem +"投票资格");
    }

}



/**
 *进入黑名单
 */
public class BlackVoteState implements VoteState {

    @Override
    public void vote(String user, String voteItem, VoteManager voteManger) {
        // TODO Auto-generated method stub
    
        System.out.println(user + "  进入黑名单，将禁止登陆和使用本系统");

    }

}

public class VoteManager {

    private VoteState state = null;
    
    private Map<String ,String > mapVote = new HashMap<String,String>();
    private Map<String,Integer> mapVoteCount = new HashMap<String ,Integer>();
    
    public Map<String,String> getMapVote() {
        return mapVote;
    }
    
    public void vote(String user,String voteItem) {
        Integer oldVOteCount = mapVoteCount.get(user);
        if(null == oldVOteCount) {
            oldVOteCount = 0;
        }
        oldVOteCount = oldVOteCount +1;
        mapVoteCount.put(user, oldVOteCount);
        
        if(oldVOteCount == 1) {
//            TODO 正常的状态
            state = new NormalVoteState();
        } else if(oldVOteCount>1 && oldVOteCount<5) {
//                TODO 重复投票
            state = new RepeatVoteState();
            
        } else if (oldVOteCount>=5 && oldVOteCount<8) {
            //TODO 恶意投票
            state = new SpiteVoteState();
        } else if(oldVOteCount >= 8) {
//            TODO 进入黑名单
            state = new BlackVoteState();
        }
        state.vote(user, voteItem, this);
    }
}

public class Client {
    public static void main(String[] args) {
        VoteManager voteManager  = new VoteManager();
        for(int i =0;i<8;i++) {
            voteManager.vote("xiaoming","明天会下雨吗？");
        }
        
    }    

}

5,状态和行为

  所谓对象的状态，通常指的就是对象实例的属性的值；而行为指的就是对象的功能，再具体点说，行为大多可以对应到方法上。

  状态模式的功能就是分离状态的行为，通过维护状态的变化，来调用不同状态对应的不同功能。

 

6，状态模式优缺点

     优点：

• • 简化引用逻辑控制
  • 更好地分离状态和行为 
  • 更好的扩展
  • 显式化进行状态转换        

 

 

     缺点：

• • 一个状态对应一个状态处理类，会使得程序引入太多的状态类，这样程序变得杂乱。
    
    

7，状态模式的本质

         

       状态模式的本质：根据状态来分离和选择行为。

  

8，何时选用状态模式

• 如果一个对象的行为取决于它的状态，而且它必须在运行时刻根据状态来改变的行为，可以使用状态模式，来把状态和行为分离开。虽然分离开了，但状态和行为是有对应关系的，可以在运行期间，通过改变状态，就能够调用到该状态对应的状态处理对象上去，从而改变对象的行为。
  
  
• 如果一个操作中包含有庞大的多分支语句，而且这些分支依赖于对象的状态，可以使用状态模式，把各个分支的处理分散包装到单独的对象处理类中，这样，就些分支对应的对象就可以不依赖于其他对象而独立变化