java设计模式-State（状态）模式

state定义 
    不同的状态,不同的行为;或者说,每个状态有着相应的行为. 
    
    就像电风扇的开关，一档的上一个是关闭，关闭的上一个是五档，五档的上一个是四档，以此类推，而且五档的下一个是关闭，关闭的下一个是一档。那么在实际应用中，我们可能会这样做： 
     在上一档的方法中：

Java代码  

1. if(level == 5){
2. level = 4;
3. do something();
4. }else if(level == 4){
5. level = 3;
6. do something();
7. } else if (level == 3){
8. level == 2;
9. do something();
10. }

在下一档的方法中：

Java代码  

1. if(level == 1){
2. level = 2;
3. do something();
4. }else if(level == 2){
5. level = 3;
6. do something();
7. } else if (level == 3){
8. level == 4;
9. do something();
10. }

单一方向的切换还好点，双方向的切换就可以考虑使用state模式了 

     假设现在有一个开关，控制三种颜色的切换，blue，green，red，蓝色下一个绿色，绿色下一个红色，红色下一个是蓝色，也可以倒过来 

代码如下：

Java代码  

1. package state;
2. /*
3. * 状态操作接口，执行上一个下一个的操作,还可以获得当前的状态
4. * 当然在这可以既执行别的操作，比如开关拨到某个颜色的时候，颜色对应的灯亮
5. */
6. public interface State {
7. public  void last(Context c);
8. public  void next(Context c);
9. public  String getState();
10. }

Java代码  

1. package state;
2. /*
3. * 蓝色状态类，实现的接口的方法，通过状态管理器在上一个或者下一个方法中
4. * 设置改变后的状态
5. */
6. public class BlueState implements State {
7. public String getState() {
8. // TODO Auto-generated method stub
9. return "blue";
10. }
11. public void last(Context c) {
12. c.setState(new GreenState());
13. }
14. public void next(Context c) {
15. c.setState(new RedState());
16. }
17. }

Java代码  

1. package state;
2. /*
3. * 绿色状态类，实现的接口的方法，通过状态管理器在上一个或者下一个方法中
4. * 设置改变后的状态
5. */
6. public class GreenState implements State {
7. public String getState() {
8. return "green";
9. }
10. public void last(Context c) {
11. c.setState(new RedState());
12. }
13. public void next(Context c) {
14. c.setState(new BlueState());
15. }
16. }

Java代码  

1. package state;
2. /*
3. * 红色状态类，实现的接口的方法，通过状态管理器在上一个或者下一个方法中
4. * 设置改变后的状态
5. */
6. public class RedState implements State {
7. public String getState() {
8. return "red";
9. }
10. public void last(Context c) {
11. c.setState(new BlueState());
12. }
13. public void next(Context c) {
14. c.setState(new GreenState());
15. }

Java代码  

1. package state;
2. /*
3. * 状态管理器，设置初始状态，得到当前状态，
4. * 提供了两个操作，上一个的操作方法中，调用了当前状态的last方法，将状态管理器的状态更新
5. *                下一个的操作方法中，调用了当前状态的next方法，将状态管理器的状态更新
6. */
7. public class Context {
8. private State state = null;
9. public State getState() {
10. return state;
11. }
12. public void setState(State state) {
13. this.state = state;
14. }
15. public void push(){
16. state.last(this);
17. System.out.println(state.getState());
18. }
19. public void pull(){
20. state.next(this);
21. System.out.println(state.getState());
22. }
23. }

Java代码  

1. package state;
2. /*
3. * 测试类
4. */
5. public class Test {
6. public static void main(String[] args) throws InterruptedException {
7. /*
8. * 创建一个状态管理器，设置初始状态为红色，
9. * 然后就可以执行状态管理器的last或者next方法
10. */
11. Context c = new Context();
12. State redsState = new RedState();
13. c.setState(redsState);
14. while (true){
15. System.out.println("当前状态："+c.getState().getState());
16. System.out.print("上一个状态: ");
17. c.push();
18. Thread.currentThread().sleep(2000);
19. }
20. }
21. }

 

    缺点也显而易见了，如果状态太多了，对应的状态类也会比较多的。。