java——状态模式（state pattern）

3.状态模式（state pattern）

 

 

 

状态模式实现的代码不复杂，不过难的是不知道什么时候用上

 

书上写得很简单

 

一个基类actor

两个继承类 happyactor，sadactor

一个状态类 里面实例化了对象actor，change（）里面改变实例化的对象，从而改变了对象

测试类，使用stage.play（），这是开心的演唱，使用stage.change（）后，因为对象改为了

sadactor，所以当使用相同的stage.play（），得到的效果是伤心的哭

通过状态的改变来改变行为，这一期间获得了动态灵活性

 

 

状态模式的好处：我个人觉得是在一些需要状态控制行为的地方，可以使用状态模式，灵活性高等等

具体用处还需实践检验

 

 

 

 

 

 

注：java深究状态模式  http://joe5456536.blog.163.com/blog/static/85374773201192252829941/

 

 

Java 设计模式 之 状态模式（State）  

 

定义：允许一个对象的内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

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

状态：对象实例的属性值。

行为：对象的功能，大多对应到方法上。

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

状态和行为是相关联的，可以描述为：状态决定行为。

状态模式和策略模式的结构师完全一样的，但它们的目的、实现、本质却完全不一样。状态模式的行为是平行的，不可相互替换的；而策略模式的行为是平等性的，是可以相互替换的。

 

 

Context ：环境，也称为上下文，用来定义客户感兴趣的接口，同时维护一个具体处理当前状态的实例对象。

State：状态接口，用来封装与上下文的一个特定状态所对应的行为。

ConcreteState：具体实现状态的处理类，每个实现一个跟上下文相关联的状态的具体处理。

 

状态处理对象的创建和销毁：

① 当需要使用状态对象的时候创建，使用完后就销毁。

② 提前创建它们并永不销毁（单例）。

③ 采用延时加载 +  缓存的方式。就是当第一次使用的时候创建，使用完后并不销毁而是把它缓存起来，下一次使用时，从缓存中获取对象，并由缓存框架来销毁状态处理对象。

 

状态的维护和转换：维护状态的数据，给状态设置不同的状态值；状态的转换，指的是根据状态的变化来选择不同的状态处理对象。

有两个地方可以进行状态的维护和转换：

① 在Context 中。② 在状态的处理类中。

如何选择者两种方式：

● 如果状态转换的规则是一定的，一般不需要进行什么扩展规则，那么就适合在上下文中统一进行状态的维护。

● 如果状态的转换取决于前一个状态动态处理的结果，或者是依赖外部数据，为了增强灵活性，这种情况下，一般式在状态处理类中进行状态的维护。 

 

 

◆ 在Context 中进行状态的维护和转换

 public interface VoteState {

          /**
           * 处理状态对应的行为
           * @param user 投票人
           * @param voteItem 投票项
           * @param manager 投票上下文，用来实现状态对应的功能处理的时候，可以回调上下文的数据
           */
           public void vote(String user, String voteItem, VoteManager manager);
}

public class NormalVoteState implements VoteState {

          @Override
          public void vote(String user, String voteItem, VoteManager manager) {
                    manager.getMapVote().put(user, voteItem);
                    System.out.println("恭喜你投票成功！");
          }
}

public class RepeatVoteState implements VoteState {

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

public class SpiteVoteState implements VoteState {

          @Override
          public void vote(String user, String voteItem, VoteManager manager) {
                    String s = manager.getMapVote().get(user);
                    if(s != null){
                             manager.getMapVote().remove(user);
                    }
                    System.out.println("你有恶意刷票行为，取消投票资格。");
          }
}

public class BlackVoteState implements VoteState {

          @Override
          public void vote(String user, String voteItem, VoteManager manager) {
                    System.out.println("进入黑名单，将禁止登陆和使用本系统。");
          }
}

public class VoteManager {

          /**
           * 持有状态处理对象
           */
          private VoteState state = null;
          /**
           * 记录用户投票的结果，Map<String,String>对应Map<用户名，投票的选项>
           */
          private Map<String, String> mapVote = new HashMap<String, String>();
          /**
           * 记录用户投票次数，Map<String,Integer> 对应Map<用户名，投票的次数>
           */
          private Map<String, Integer> mapVoteCount = new HashMap<String, Integer>();
          /**
           * 获取记录用户投票结果的Map
           * @return 记录用户投票结果的Map
           */
          public Map<String, String> getMapVote() {
                    return mapVote;
          }
          /**
           * 投票
           * @param user 投票人
           * @param voteItem 投票的选项
           */
          public void vote(String user, String voteItem){
                    Integer oldVoteCount = mapVoteCount.get(user);
                    if(oldVoteCount == null){
                           oldVoteCount = 0;
                    }
                    oldVoteCount++;
                    mapVoteCount.put(user, oldVoteCount);
                    if(oldVoteCount == 1){
                             state = new NormalVoteState();
                    }else if(oldVoteCount > 1 && oldVoteCount < 5){
                             state = new RepeatVoteState();
                    }else if(oldVoteCount >= 5 && oldVoteCount < 8){
                             state = new SpiteVoteState();
                    }else if(oldVoteCount >= 8){
                             state = new BlackVoteState();
                    }
                    state.vote(user, voteItem, this);
           }
}

public class Client {

          public static void main(String[] args) {
                    VoteManager manager = new VoteManager();
                    for(int i = 0; i < 8; i++){
                           manager.vote("JOE", "A");
                    }
          } 
}

#########################################################################################################

◆ 在状态处理类中进行状态的维护和转换

public interface VoteState {

          public void vote(String user, String voteItem, VoteManager manager);
}

public class NormalVoteState implements VoteState {

          @Override
          public void vote(String user, String voteItem, VoteManager manager) {
                    manager.getMapVote().put(user, voteItem);
                    System.out.println("投票成功！");
                    manager.getMapState().put(user, new RepeatVoteState());
         }
}

public class RepeatVoteState implements VoteState {

          @Override
          public void vote(String user, String voteItem, VoteManager manager) {
                    System.out.println("请不要重复投票。");
                    if(manager.getMapVoteCount().get(user) >= 4){
                             manager.getMapState().put(user, new SpiteVoteState());
                    }
         }
}
public class SpiteVoteState implements VoteState {

          @Override
          public void vote(String user, String voteItem, VoteManager manager) {
                    String s = manager.getMapVote().get(user);
                    if(s != null){
                             manager.getMapVote().remove(user);
                    }
                    System.out.println("你有恶意刷票行为，取消投票资格。");
                   if(manager.getMapVoteCount().get(user) >= 7){
                              manager.getMapState().put(user, new BlackVoteState());
                   }
         }
}

public class BlackVoteState implements VoteState {

          @Override
          public void vote(String user, String voteItem, VoteManager manager) {
                     System.out.println("你进入了黑名单。");
          }
}

public class VoteManager {
          /**
           * 记录当前每个用户对应的状态处理对象，每个用户当前的状态是不同的
           * Map<String, VoteState>对应Map<用户名，当前对应的状态处理对象>
           */
          private Map<String, VoteState> mapState = new HashMap<String, VoteState>();
          /**
           * 记录用户投票的结果，Map<String,String>对应Map<用户名，投票的选项>
           */
          private Map<String, String> mapVote = new HashMap<String, String>();
          /**
           * 记录用户投票次数，Map<String,Integer> 对应Map<用户名，投票的次数>
           */
          private Map<String, Integer> mapVoteCount = new HashMap<String, Integer>();
          /**
           * 获取记录用户投票结果的Map
           * @return 记录用户投票结果的Map
           */
          public Map<String, String> getMapVote() {
                    return mapVote;
          }
          /**
           * 获取记录当前每个用户对应的状态处理对象
           * @return
           */
          public Map<String, VoteState> getMapState() {
                    return mapState;
          }
          /**
           * 获取记录每个用户对应的投票次数的Map
           * @return
           */
          public Map<String, Integer> getMapVoteCount() {
                    return mapVoteCount;
          }
 
          public void vote(String user, String voteItem){
                    Integer oldVoteCount = mapVoteCount.get(user);
                    if(oldVoteCount == null){
                             oldVoteCount = 0;
                    }
                   oldVoteCount++;
                   mapVoteCount.put(user, oldVoteCount);
  
                   VoteState state = mapState.get(user);
                   if(state == null){
                           state = new NormalVoteState();
                   }
                   state.vote(user, voteItem, this);
          } 
}

public class Client {

          public static void main(String[] args) {
                    VoteManager manager = new VoteManager();
                    for(int i = 0; i < 8; i++){
                           manager.vote("JOE", "A");
                    }
          } 
}

评论

1 楼 kensunhu 2012-06-14  

阐述相当完整，例子非常精彩。就是类图不见啦。