Java设计模式--状态模式

状态模式(别名:状态对象)

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

State Pattern(Another Name: Object for States)

Allow an object to alert its behavior when its internal state changes. The object will appear to change its class.

类图

模式的结构与使用

状态模式的结构中包括三种角色。

  • 环境(Context):环境是一个类,该类含有抽象状态(State)声明的变量,可以引用任何具体状态类的实例。用户对该环境(Context)类的实例在某种状态下的行为感兴趣。
  • 抽象状态(State):抽象状态是一个接口或抽象类。抽象状态中定义了与环境(Context)的一个特定状态相关的如果个方法。
  • 具体状态(Concrete State):具体状态是实现(扩展)抽象状态(抽象类)的类。

简单的例子

State的接口类TemperatureState.java

1
2
3
4
5
package State;
public interface TemperatureState {
public void showTemperature();
}

Context环境类Thermometer.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package State;
public class Thermometer {
TemperatureState state;
public void showMessage() {
System.out.println("*************");
state.showTemperature();
System.out.println("*************");
}
public void setState(TemperatureState state) {
this.state = state;
}
}

ConcreteState的实现类LowState.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package State;
public class LowState implements TemperatureState {
double n = 0;
public LowState(double n) {
if (n < 0) {
this.n = n;
}
}
@Override
public void showTemperature() {
System.out.println("现在的温度是" + n + "属于低温度");
}
}

ConcreteState的实现类MiddleState.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package State;
public class MiddleState implements TemperatureState {
double n = 15;
public MiddleState(double n) {
if (n > 0 && n < 26) {
this.n = n;
}
}
@Override
public void showTemperature() {
System.out.println("现在的温度是" + n + "属于正常温度");
}
}

ConcreteState的实现类HighState..java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package State;
public class HighState implements TemperatureState {
double n = 39;
public HighState(double n) {
if (n > 26) {
this.n = n;
}
}
@Override
public void showTemperature() {
System.out.println("现在的温度是" + n + "属于高温");
}
}

测试类Application.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package State;
public class Application {
public static void main(String[] args) {
TemperatureState state = new LowState(-12);
Thermometer thermometer = new Thermometer();
thermometer.setState(state);
thermometer.showMessage();
state = new MiddleState(15);
thermometer.setState(state);
thermometer.showMessage();
state = new HighState(40);
thermometer.setState(state);
thermometer.showMessage();
}
}

状态模式的优点

  • 使用一个类封装对象的一种状态,很容易增加新的状态。
  • 在状态模式中,环境(Context)中不必出现大量的条件判断语句。环境(Context)实例所呈现的状态变得更加清晰、容易理解。
  • 使用状态模式可以让用户程序很方便地切换环境(Context)实例的状态。
  • 使用状态模式不会让环境(Context)的实例中出现内部状态不一致的情况。
  • 当状态对象没有实例变量时,环境(Context)的各个实例可以共享一个状态对象。

适用状态模式的情景

  • 一个对象的行为依赖于它的状态,并且它必须在运行时根据状态改变它的行为。
  • 需要编写大量的条件分支语句来决定一个操作的行为,而且这些条件恰好表示对象的一种状态。

下载源码请到

MyGitHub

文章目录
  1. 1. 状态模式(别名:状态对象)
  2. 2. State Pattern(Another Name: Object for States)
  3. 3. 类图
  4. 4. 模式的结构与使用
  5. 5. 简单的例子
    1. 5.1. State的接口类TemperatureState.java
    2. 5.2. Context环境类Thermometer.java
    3. 5.3. ConcreteState的实现类LowState.java
    4. 5.4. ConcreteState的实现类MiddleState.java
    5. 5.5. ConcreteState的实现类HighState..java
    6. 5.6. 测试类Application.java
  6. 6. 状态模式的优点
  7. 7. 适用状态模式的情景
  8. 8. 下载源码请到