JAVA设计模式——状态模式

状态模式，又称状态对象模式（Pattern of Objects for States），是一种行为型设计模式。其思想是：允许一个对象在其内部状态改变的时候改变其行为。

状态模式涉及3个角色：

环境（Context）：持有一个具体状态的引用和一些供客户使用的方法。

抽象状态（State）：定义一个接口，用以封装环境对象的一个特定的状态所对应的行为。

具体状态（Concrete State）：每一个具体状态类都实现了环境的一个状态所对应的行为。

结构图：



具体代码实现：

状态：

public interface State {
void method1();
void method2();
void method3();
}

public class ConcreteStateA implements State {
@Override
public void method1() {
System.out.println("State A Method 1");
}

@Override
public void method2() {
System.out.println("State A Method 2");
}

@Override
public void method3() {
System.out.println("State A Method 3");
}
}

public class ConcreteStateB implements State {
@Override
public void method1() {
System.out.println("State B Method 1");
}

@Override
public void method2() {
System.out.println("State B Method 2");
}

@Override
public void method3() {
System.out.println("State B Method 3");
}
}

环境：

public class Context {
private State state;

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

public void request1() {
state.method1();
}

public void request2() {
state.method2();
}

public void request3() {
state.method3();
}
}

客户：

public class Client {
public void method() {
Context context = new Context();

context.setState(new ConcreteStateA());
context.request1();
context.request2();
context.request3();

System.out.println("==========");
context.setState(new ConcreteStateB());
context.request1();
context.request2();
context.request3();
}
}

// 测试
class StateTest {
public static void main(String[] args) {
Client client = new Client();
client.method();
}
}

运行结果：

State A Method 1

State A Method 2

State A Method 3

==========

State B Method 1

State B Method 2

State B Method 3

也许你会觉得状态模式和策略模式很相似，如果上面的例子，环境类和状态接口简化到只有一个实现方法，那么结构上和策略模式是一模一样的。

策略模式和状态模式最重要的一个区别是：策略模式是基于单个算法的，各个具体的策略类是对这个算法的不同实现；而状态模式则是基于整个环境（Context）类的，环境中所有的算法，在各个具体状态中都必须一一实现。

下面提供两个比较例子：

策略模式：

// 抽象策略
public interface Car {
void goToWork(); // 针对单个算法的实现
}

// 具体策略
public class BMW implements Car {
@Override
public void goToWork() {
System.out.println("i am going to work by BMW...");
}
}

// 具体策略
public class Benz implements Car {
@Override
public void goToWork() {
System.out.println("i am going to work by Benz...");
}
}

// 具体策略
public class Porsche implements Car {
@Override
public void goToWork() {
System.out.println("i am going to work by Porsche...");
}
}

// 环境
public class Me {
private Car car; // 持有一个策略对象的引用

public void setCar(Car car) {
this.car = car;
}

public void goShopping() {

}

public void goToWork() {
car.goToWork(); // 委托策略对象执行算法
}

public void goToSchool() {

}
}

状态模式：

// 抽象状态，对环境中的每个算法都需要提供一个实现
public interface Car {
void goShopping();
void goToWork();
void goToSchool();
}

// 具体状态
public class BMW implements Car {
@Override
public void goShopping() {
System.out.println("i am going shopping by BMW");
}

@Override
public void goToWork() {
System.out.println("i am going to work by BMW");
}

@Override
public void goToSchool() {
System.out.println("i am going to school by BMW");
}
}

// 具体状态
public class Benz implements Car {
@Override
public void goShopping() {
System.out.println("i am going shopping by Benz");
}

@Override
public void goToWork() {
System.out.println("i am going to work by Benz");
}

@Override
public void goToSchool() {
System.out.println("i am going to school by Benz");
}
}

// 具体状态
public class Porsche implements Car {
@Override
public void goShopping() {
System.out.println("i am going shopping by Porsche");
}

@Override
public void goToWork() {
System.out.println("i am going to work by Porsche");
}

@Override
public void goToSchool() {
System.out.println("i am going to school by Porsche");
}
}

// 环境
public class Me {
private Car car; // 持有一个状态对象的引用

public void setCar(Car car) {
this.car = car;
}

// 以下的方法，根据状态的不同，会有不一样的实现

public void goShopping() {
car.goShopping();
}

public void goToWork() {
car.goToWork();
}

public void goToSchool() {
car.goToSchool();
}
}

状态模式实现了系统的松耦合，但同时会增加系统类和对象的个数，而且的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。