状态模式的场景应用

现在遇到了这样一个场景：要将一系列操作自动化，其中涉及到一些状态以及状态的转移。状态有4种：初始状态0，第一步A，第二步B，第三步C。其中这几个状态间的转移关系就略去了，抽象出来是这样的：无论从哪种状态转移到目标状态，做出的行为都是表示“到目标状态”所做的行为，即与上一步状态无关，只与目标状态有关。故使用状态模式实现。简单说明问题的代码如下：

状态管理：

public class StateManager {
    private State state;
    private StateManager() {}
    public StateManager(State state) {this.state = state;}
    public StateManager(String state) {... // 根据状态码初始化云云}
    public State getState() {return state;}
    public void setState(State state) {this.state = state;}
    public void to0() {state.to0(this);}
    public void toA() {state.toA(this);}
    public void toB() {state.toB(this);}
    public void toC() {state.toC(this);}
}

状态接口：

public interface State {
    void to0(StateManager sm);
    void toA(StateManager sm);
    void toB(StateManager sm);
    void toC(StateManager sm);
}

抽象父类：

public abstract class AbstractState implement State {
    public void to0(StateManager sm) { throw new UnsupportedOperationException();}
    public void toA(StateManager sm) { throw new UnsupportedOperationException();}
    public void toB(StateManager sm) { throw new UnsupportedOperationException();}
    public void toC(StateManager sm) { throw new UnsupportedOperationException();}
}

具体子类：

public class State0 extends AbstractState {
    public void toA(StateManager sm) { print("toA");sm.setState(new StateA()); } // 允许转移到A
}

public class StateA extends AbstractState {
    public void to0(StateManager sm) { print("to0");sm.setState(new State0()); } // 允许重置
    public void toB(StateManager sm) { print("toB");sm.setState(new StateB()); } // 允许转移到B
    public void toC(StateManager sm) { print("toC");sm.setState(new StateC()); } // 允许转移到C
}

public class StateB extends AbstractState {
    public void to0(StateManager sm) { print("to0");sm.setState(new State0()); } // 允许重置
    public void toC(StateManager sm) { print("toC");sm.setState(new StateC()); } // 允许转移到C
}

public class StateC extends AbstractState {
    public void to0(StateManager sm) { print("to0");sm.setState(new State0()); } // 允许重置
    public void toC(StateManager sm) { print("toC_Again"); } // 覆盖，走另一个逻辑
}

简单举例吧，状态转移就点到为止。至此一个由基本的状态模式改造的模型就写完了，一个抽象父类提供一个默认抛出不支持异常的方法，子类需要实现转移到哪个状态，就重写哪个方法。问题很明显，代码冗余很严重。发现toC方法写错了，我要改3个地方。Java容器类库里AbstractList里提供默认抛出不支持操作异常的目的是避免接口爆炸，不能随随便便就抄过来的。但是，这个逻辑还是有应用在这个场景下的味道在里面的，只不过用反了。不应该是给无能者赋予能力，而是给健全者予以阉割！第二版更改如下：

抽象父类：

public abstract class AbstractState implement State {
    public void to0(StateManager sm) { print("to0");sm.setState(new State0()); } // 允许重置
    public void toA(StateManager sm) { print("toA");sm.setState(new StateA()); } // 允许转移到A
    public void toB(StateManager sm) { print("toB");sm.setState(new StateB()); } // 允许转移到B
    public void toC(StateManager sm) { print("toC");sm.setState(new StateC()); } // 允许转移到C
}

具体子类：

public class State0 extends AbstractState {
    public void to0(StateManager sm) { throw new UnsupportedOperationException();} // 禁止的状态转移阉割掉
    public void toB(StateManager sm) { throw new UnsupportedOperationException();} // 禁止的状态转移阉割掉
    public void toC(StateManager sm) { throw new UnsupportedOperationException();} // 禁止的状态转移阉割掉
}
 
public class StateA extends AbstractState {
    public void toA(StateManager sm) { throw new UnsupportedOperationException();} // 禁止的状态转移阉割掉
}

public class StateB extends AbstractState {
    public void toA(StateManager sm) { throw new UnsupportedOperationException();} // 禁止的状态转移阉割掉
    public void toB(StateManager sm) { throw new UnsupportedOperationException();} // 禁止的状态转移阉割掉
}

public class StateC extends AbstractState {
    public void toA(StateManager sm) { throw new UnsupportedOperationException();} // 禁止的状态转移阉割掉
    public void toB(StateManager sm) { throw new UnsupportedOperationException();} // 禁止的状态转移阉割掉
    public void toC(StateManager sm) { print("toC_Again"); } // 覆盖，走另一个逻辑
}

第二版修复了第一版出现的问题，所有实现功能的代码只出现了一次，，但还是不够好，抽象类的作用已经发生了变化，和接口有重叠。鉴于状态不会再有变动，接口可以去掉了，留抽象类足矣。

感觉还是不够好，写得很垃圾，以后再改吧，现在这样足够能用了，也没有多线程场景，不过以后要是有的话问题可就大了。

欢迎提出意见指正