Java 状态模式

《设计模式》对状态模式的定义:允许一个对象在其状态改变时，改变它的行为。看起来对象似乎修改了它的类。别名：状态对象（Objects for State）。
在下面两种情况下均可以使用State模式：
1 一个对象的行为取决于它的状态，并且他必须在运行时刻根据状态改变它的行为。
2 一个操作中含有庞大的多分枝的条件语句，并且这些分支依赖于该对象的状态。这个状态通常用一个或多个枚举常量表示。通常，有多个操作包含这一相同的条件结构。State模式将每一个条件分支放入一个独立的类中。这是得你可以根据对象自身的情况将对象的状态作为一个对象，这一对象可以不依赖于其他对象而独立变化。

结构如下：

为了帮助理解，我们举例来说明：
一个画图程序，有一个控制面板，上面罗列了各种画图工具以及其它颜色选择，滴管等工具，当用户选择或改变了画图工具时，就可以使用各种不同的工具进行画图或其他操作了。
我们先使用一般的方法（非State模式）来模拟选择画笔工具画图的过程：

//画笔工具选择事件处理方法
public void onSelectPen(int state) {
    //根据不同的选择创建不同的画笔工具，然后画图
    if (state == CIRCLE_PEN) {
        CirclePen cp = new CirclePen();    //创建圆形画笔
        cp.drawCircle(paramters);    //画圆形
    } else     if (state == SQUARE_PEN) {
        SquarePen sp = new SquarePen();    //创建方形画笔
        sp.drawSquare(paramters);    //画方形
    } else     if (state == LINE_PEN) {
        LinePen lp = new LinePen();
        lp.drawLine(paramters);
    }
    ...    //其他画笔

可以看到，需要为每一个画笔工具加一个判断条件，当画笔工具有增减或非常多时，代码不得不跟着作大量修改。State模式对各种状态行为加以抽象，为每一个可能的状态创建一个状态类的子类，并通过一个Context类管理状态子类对象的当前状态，对状态子类的调用加以封装。用户可以通过改变Context类对象所管理的状态来改变不同状态的行为。
用状态模式实现的代码如下：

import java.util.*;

// 画图工具的接口
interface State {
public void draw();
}

// 画线工具类
class Line implements State {

@Override
public void draw() {
   // TODO Auto-generated method stub
   System.out.println("画出一条直线");
}
}

// 画圆工具类
class Circle implements State {

@Override
public void draw() {
   // TODO Auto-generated method stub
   System.out.println("画出一个圆");
}
}

// 橡皮擦工具类
class Empty implements State {

@Override
public void draw() {
   // TODO Auto-generated method stub
   System.out.println("擦除画板");
}
}

// 配置各个工具状态
class Context {
// 保持各种工具的列表
Map<String, State> toolBar = new HashMap<String, State>();

State toolState;

public void addState(String name,State state){
   toolBar.put(name, state);
}

// 改变状态
public void selectState(String name){
   toolState = toolBar.get(name);
}

// 执行具体的动作
public void action(){
   toolState.draw();
}
}

// 测试类
public class Client {
public static void main(String[] args) {
   Context tool = new Context();
  
   tool.addState("line", new Line());
   tool.addState("circle",new Circle());
   tool.addState("empty", new Empty());
  
   tool.selectState("line");
   tool.action();
  
   tool.selectState("empty");
   tool.action();
  
   tool.selectState("circle");
   tool.action();
}
}

输出:
画出一条直线
擦除画板
画出一个圆

优点： 避免了为判断状态而产生的巨大的if或case语句。 将对象行为交给状态类维护后，对于上层程序而言，仅需要维护状态之间的转换规则。
缺点：会导致某些系统有过多的具体状态类。

-------------------------------------------------------------------------------------------------------------------------------------------

一 个对象有多种状态，在不同的状态下，同一种方法有不同的行为。如果用swich-case语句，将有大量的条件分支和逻辑代码混在一起。状态模式将每个状态封装到一个独立的类中，利用多态性使得不同状态下同一种方法表现不同的行为。

状态模式的UML图如下：

星际中人族的机枪兵Marine有两种状态：普通状态和打了兴奋针后的状态，两种状态下机枪兵的开枪频率是不同的，我们用状态模式来实现机枪兵的fire()方法。

首先定义抽象状态State接口，这个接口指定了机枪兵的fire行为：

public interface State {

      public void fire();

}

State接口有一个fire()方法，我们实现两个子类NormalState和ExcitedState，分别表示普通状态和打了兴奋针后的状态，并实现具体的fire方法：

public class NormalState implements State {

      public void fire() {

         System.out.println("普通状态每秒开枪1次。");

      }

}

public class ExcitedState implements State {

      public void fire() {

         System.out.println("兴奋状态每秒开枪2次。");

      }
}

最后，定义机枪兵类Marine，每个Marine的实例代表一个机枪兵：

public class Marine {

      // 保持一个状态类的实例：

      private State state = new NormalState();

      // 为机枪兵设置状态：

      public void setState(State state) {

         this.state = state;

      }

      // fire()方法，实际调用的是state变量的fire()方法：

      public void fire() {

         state.fire();

      }

}

最后我们看看如何在客户端控制一个机枪兵的状态：

        public static void main(String[] args) {  
               
   Marine marine = new Marine();    // 创建一个机枪兵的实例：  
                                  
                       marine.fire();    // 调用fire()方法：   
                                 
                       marine.setState(new ExcitedState()); // 设置为兴奋状态：   
                                    
 

               marine.fire();   // 再调用fire()方法：

}

对同一个Marine对象调用两次fire()方法，屏幕输出为：

普通状态每秒开枪1次。

兴奋状态每秒开枪2次。

可见机枪兵在两种状态下的同一个fire()方法有不同的行为。

使用状态模式的好处是每个状态被封装到一个独立的类中，这些类可以独立变化，而主对象中没有繁琐的swich-case语句，并且添加新的状态非常容易，只需要从State派生一个新类即可。

 

Java 中的模式 --- 简单的状态模式

状态模式很简单，无论是理解，还是实现，都很简单。
一、定义：
1，状态模式允许一个"对象"在其内部状态改变的时候改变其行为。
2，状态模式的角色：
抽象状态，具体状态，环境(context)角色
状态模式的角色比较简单，不用解释了，看名字就能了解。
二、状态模式的实现
1,简单实例

1 public class Context {
2    private State state;
3    publicvoid sampleOperation(){
4         state.sampleOperation();
5     }
6    publicvoid setState(State state){
7        this.state = state;
8     }
9}
10 public interface State {
11    void sampleOperation();
12}
13 public class ConcreteState implements State {
14    publicvoid sampleOperation();
15}

2、状态模式的经典实现
Tcp就是状态模式的一个经典实现：TcpConnect 他有三个状态，TcpEstablished TcpListen TcpClosed
TcpConnect的功能会跟着状态的改变而改变。或是Established,或是Listen,或是Closed
三、状态模式的与策略模式，看到上边的部分，很容易让人想到策略模式，这两个模式有什么区别呢？如何使用
策略模式：
1，当一个环境角色选择了一个具体的策略，那么在整个环境类的生命周期都不会改变
2，策略模式的环境自己选择一个具体的策略
3，策略模式并不明确告诉客户端它所选择的具体策略是什么，对客户是黑箱。
状态模式：
1，在整个环境类的生命周期中会有明显的状态改变。
2，状态模式是被外在原因放入一个策略
3,状态模式明显的告诉客户端当前的状态，对客户是白箱。