设计模式（十六）——状态模式

1.描述

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

2.模式的使用

·环境(Context)：环境是一个类，该类含有抽象状态（State）的声明，可以引用任何具体状态类的实例。用户对该环境（Context）类的实例在某种状态下的行为感兴趣。

·抽象状态(State)：抽象状态是一个接口或抽象类。抽象状态中定义了与环境（Context）的一个特定状态相关的若干个方法。

·具体状态(Concrete State)：具体状态是实现（扩展）抽象状态的类。

3.使用情景

·一个对象的行为依赖他的状态，并且他必须在运行时根据状态改变他的行为。

·需要编写大量的条件分支语句来决定一个操作的行为，并且这些条件恰好表示对象的一种状态。

4.优点

·容易增加新的状态。

·环境（Context）中不必出现大量条件语句。

·可以让用户方便的切换环境（Context）实例的状态。

·避免环境（Context）实例出现内部状态不一致的情况。

·当状态对象没有实例变量时，环境（Context）的各个实例可以共享一个状态对象。

5.UML图

6案例

案例一

一个温度计（环境），在不同温度（状态）时显示不同信息。

package 状态模式;

public class test1 {

    public static void main(String[] args) {
        Thermometer t = new Thermometer();
        HeightState h = new HeightState(20);
        LowState l = new LowState(-20);
        t.setState(h);
        t.show();
        t.setState(l);
        t.show();
    }

}

/*
 * 环境
 */
class Thermometer {
    TemperatureState state;
    public void setState(TemperatureState temperatureState){
        this.state = temperatureState;
    }
    public void show(){
        System.out.println("**********");
        state.showTemperature();
        System.out.println("**********");
    }
}

/*
 * 抽象状态
 */
interface TemperatureState {
    public void showTemperature();
}

/*
 * 具体状态
 */
class LowState implements TemperatureState {
    double n = 0;
    LowState(double n){
        if(n <= 0)
            this.n = n;
    }
    public void showTemperature() {
        System.out.println("现在的温度是：" + n + "°，属于低温");    
    }
    
}

/*
 * 具体状态
 */
class HeightState implements TemperatureState {
    double n = 0;
    HeightState(double n){
        if(n > 0)
            this.n = n;
    }
    public void showTemperature() {
        System.out.println("现在的温度是：" + n + "°，属于高温");    
    }
    
}

案例二：状态切换（环境实例在某种状态下执行一个方法后，可能导致该实例的状态发生变化）

一把枪（环境），有2颗子弹、一颗子弹、无子弹三种状态，有开枪和装弹两种操作。在有子弹时才能开枪，在无子弹时才能装弹。

package 状态模式;

public class test2 {

    public static void main(String[] args) {
        Gun gun = new Gun();
        gun.fire();
        gun.fire();
        gun.fire();
        gun.load();
    }

}

/*
 * 环境
 */
class Gun {
    State state1, state2, state3;
    State state;
    Gun(){
        this.state1 = new State1(this);
        this.state2 = new State2(this);
        this.state3 = new State3(this);
        state = state1;
    }
    
    public void setState(State state){
        this.state = state;
    }

    public State getState1() {
        return state1;
    }

    public State getState2() {
        return state2;
    }

    public State getState3() {
        return state3;
    }

    public State getState() {
        return state;
    }
    
    public void fire(){
        state.fire();
    }
    
    public void load(){
        state.loadBullet();
    }
}

/*
 * 抽象状态
 */
interface State {
    public void fire();
    public void loadBullet();
    public String showStateMess();
}

/*
 * 具体状态
 */
class State1 implements State {
    Gun gun;
    State1(Gun gun){
        this.gun = gun;
    }
    public void fire() {
        // TODO Auto-generated method stub
        System.out.println("射出一颗子弹");
        gun.setState(gun.getState2());
        System.out.println("进入" + gun.getState2().showStateMess());
    }

    public void loadBullet() {
        // TODO Auto-generated method stub
        
    }

    public String showStateMess() {
        // TODO Auto-generated method stub
        return "2颗子弹状态";
    }
    
}

/*
 * 具体状态
 */
class State2 implements State {
    Gun gun;
    State2(Gun gun){
        this.gun = gun;
    }
    public void fire() {
        // TODO Auto-generated method stub
        System.out.println("射出一颗子弹");
        gun.setState(gun.getState3());
        System.out.println("进入" + gun.getState3().showStateMess());
    }

    public void loadBullet() {
        System.out.println("无法装弹");
        
    }

    public String showStateMess() {
        // TODO Auto-generated method stub
        return "一颗子弹状态";
    }
    
}

/*
 * 具体状态,空弹夹
 */
class State3 implements State {
    Gun gun;
    State3(Gun gun){
        this.gun = gun;
    }
    public void fire() {
        // TODO Auto-generated method stub
        System.out.println("无法射出子弹");
        System.out.println("目前是" + showStateMess() + "");
    }

    public void loadBullet() {
        System.out.println("装弹");
        gun.setState(gun.getState1());
        System.out.println("进入" + gun.getState1().showStateMess());
    }

    public String showStateMess() {
        // TODO Auto-generated method stub
        return "无子弹状态";
    }
    
}

案例三：共享状态（多个实例共享同一个状态）

一列火车的各个车厢同时处于运动状态或静止状态，为了实现这个目的需要将状态设置为静态变量。

package 状态模式;

public class test3 {

    public static void main(String[] args) {
        Vehicle car1 = new Vehicle("卧铺车厢");
        Vehicle car2 = new Vehicle("硬座车厢");
        car1.startUp();
        car2.startUp();
        car2.stop();
        car1.stop();
    }

}

/*
 * 环境
 */
class Vehicle {
    static StateOne moveState, stopState;
    static StateOne state;
    String name;
    Vehicle(String name){
        this.name = name;
        this.moveState = new VehicleMoveState();
        this.stopState = new VehicleStopState();
        state = stopState;
    }
    
    public void startUp(){
        state.startUp(this);
    }
    
    public void stop(){
        state.stop(this);
    }
    
    public void setState(StateOne state){
        this.state = state;
    }

    public static StateOne getMoveState() {
        return moveState;
    }

    public static StateOne getStopState() {
        return stopState;
    }

    public static StateOne getState() {
        return state;
    }

    public String getName() {
        return name;
    }
}

/*
 * 抽象状态
 */
interface StateOne {
    public void startUp(Vehicle vehicle);
    public void stop(Vehicle vehicle);
}

class VehicleMoveState implements StateOne{

    public void startUp(Vehicle vehicle) {
        System.out.println(vehicle.getName() + "已经在运动状态");
    }

    public void stop(Vehicle vehicle) {
        System.out.println(vehicle.getName() + "停止运动");
        vehicle.setState(vehicle.getStopState());
    }
    
}

class VehicleStopState implements StateOne{

    public void startUp(Vehicle vehicle) {
        System.out.println(vehicle.getName() + "开始运动");
        vehicle.setState(vehicle.getMoveState());
    }

    public void stop(Vehicle vehicle) {
        System.out.println(vehicle.getName() + "已经在静止状态");
    }
    
}