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();
    }
}

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