【Java设计模式】十七、状态模式

快来打我* 2024-04-23 15:54 71阅读 0赞

#### 文章目录 ####

*  1、背景案例
 *  2、状态模式
 *  3、案例
 *  4、总结

## 1、背景案例 ##

现要按钮控制电梯的四种状态：开门、关门、启动、停止。但每种状态的改变，可能受其他状态影响，如运行状态下，不能进行开门。写个普通实现：

![在这里插入图片描述][b42da57b824f4ea499beb00eef2da50d.png]

定义电梯接口

public interface ILift {
        
        //电梯的4个状态
        //开门状态
        public final static int OPENING_STATE = 1;
        //关门状态
        public final static int CLOSING_STATE = 2;
        //运行状态
        public final static int RUNNING_STATE = 3;
        //停止状态
        public final static int STOPPING_STATE = 4;
    
        //设置电梯的状态
        public void setState(int state);
    
        //电梯的动作
        public void open();   //开门
        public void close();  //关门
        public void run();   //运行
        public void stop();  //停止
    }

写子实现类，电梯类：

public class Lift implements ILift {
        
    	//状态
        private int state;
    
        @Override
        public void setState(int state) {
        
            this.state = state;
        }
    
        //执行关门动作
        @Override
        public void close() {
        
            switch (this.state) {
        
                case OPENING_STATE:
                    System.out.println("电梯关门了。。。");//只有开门状态可以关闭电梯门
                    this.setState(CLOSING_STATE);//关门之后电梯就是关闭状态了
                    break;
                case CLOSING_STATE:
                    //do nothing //已经是关门状态，不能关门
                    break;
                case RUNNING_STATE:
                    //do nothing //运行时电梯门是关着的，不能关门
                    break;
                case STOPPING_STATE:
                    //do nothing //停止时电梯也是关着的，不能关门
                    break;
            }
        }
    
        //执行开门动作
        @Override
        public void open() {
        
            switch (this.state) {
        
                case OPENING_STATE: //门已经开了，不能再开门了
                    //do nothing
                    break;
                case CLOSING_STATE: //关门状态，门打开:
                    System.out.println("电梯门打开了。。。");
                    this.setState(OPENING_STATE);
                    break;
                case RUNNING_STATE:
                    //do nothing 运行时电梯不能开门
                    break;
                case STOPPING_STATE:
                    System.out.println("电梯门开了。。。");//电梯停了，可以开门了
                    this.setState(OPENING_STATE);
                    break;
            }
        }
    
        //执行运行动作
        @Override
        public void run() {
        
            switch (this.state) {
        
                case OPENING_STATE: //电梯不能开着门就走
                    //do nothing
                    break;
                case CLOSING_STATE: //门关了，可以运行了
                    System.out.println("电梯开始运行了。。。");
                    this.setState(RUNNING_STATE);//现在是运行状态
                    break;
                case RUNNING_STATE:
                    //do nothing 已经是运行状态了
                    break;
                case STOPPING_STATE:
                    System.out.println("电梯开始运行了。。。");
                    this.setState(RUNNING_STATE);
                    break;
            }
        }
    
        //执行停止动作
        @Override
        public void stop() {
        
            switch (this.state) {
        
                case OPENING_STATE: //开门的电梯已经是是停止的了(正常情况下)
                    //do nothing
                    break;
                case CLOSING_STATE: //关门时才可以停止
                    System.out.println("电梯停止了。。。");
                    this.setState(STOPPING_STATE);
                    break;
                case RUNNING_STATE: //运行时当然可以停止了
                    System.out.println("电梯停止了。。。");
                    this.setState(STOPPING_STATE);
                    break;
                case STOPPING_STATE:
                    //do nothing
                    break;
            }
        }
    }

测试下：

public class Client {
        
        public static void main(String[] args) {
        
            Lift lift = new Lift();
            lift.setState(ILift.STOPPING_STATE);//电梯是停止的
            lift.open();//开门
            lift.close();//关门
            lift.run();//运行
            lift.stop();//停止
        }
    }

以上：十六个switch…case会让可读性很差。此外，若要新加断电状态，则全都要改动。

## 2、状态模式 ##

对有状态的对象（电梯），把复杂的逻辑判断提取到不同的**状态对象**中。角色：

*  环境角色
 *  抽象状态
 *  具体状态

## 3、案例 ##

改进上面的电梯案例：

![在这里插入图片描述][4c69a9d0ad344cb384eb425cfc430b12.png]

定义抽象状态类，里面聚合环境角色类：

//抽象状态类
    public abstract class LiftState {
        
    
        //定义一个环境角色，也就是封装状态的变化引起的功能变化
        protected Context context;
    
        public void setContext(Context context) {
        
            this.context = context;
        }
    
        //电梯开门动作
        public abstract void open();
    
        //电梯关门动作
        public abstract void close();
    
        //电梯运行动作
        public abstract void run();
    
        //电梯停止动作
        public abstract void stop();
    }

声明四种状态对象，继承抽象状态类：

//开启状态
    public class OpenningState extends LiftState {
        
    
        //开启当然可以关闭了，我就想测试一下电梯门开关功能
        @Override
        public void open() {
        
            System.out.println("电梯门开启...");
        }
    
        @Override
        public void close() {
        
            //状态修改
            super.context.setLiftState(Context.closeingState);
            //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
            super.context.getLiftState().close();
        }
    
        //电梯门不能开着就跑，这里什么也不做
        @Override
        public void run() {
        
            //do nothing
        }
    
        //开门状态已经是停止的了
        @Override
        public void stop() {
        
            //do nothing
        }
    }

//运行状态
    public class RunningState extends LiftState {
        
    
        //运行的时候开电梯门？你疯了！电梯不会给你开的
        @Override
        public void open() {
        
            //do nothing
        }
    
        //电梯门关闭？这是肯定了
        @Override
        public void close() {
        //虽然可以关门，但这个动作不归我执行
            //do nothing
        }
    
        //这是在运行状态下要实现的方法
        @Override
        public void run() {
        
            System.out.println("电梯正在运行...");
        }
    
        //这个事绝对是合理的，光运行不停止还有谁敢做这个电梯？！估计只有上帝了
        @Override
        public void stop() {
        
            super.context.setLiftState(Context.stoppingState);
            super.context.stop();
        }
    }

//停止状态
    public class StoppingState extends LiftState {
        
    
        //停止状态，开门，那是要的！
        @Override
        public void open() {
        
            //状态修改
            super.context.setLiftState(Context.openningState);
            //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
            super.context.getLiftState().open();
        }
    
        @Override
        public void close() {
        //虽然可以关门，但这个动作不归我执行
            //状态修改
            super.context.setLiftState(Context.closeingState);
            //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
            super.context.getLiftState().close();
        }
    
        //停止状态再跑起来，正常的很
        @Override
        public void run() {
        
            //状态修改
            super.context.setLiftState(Context.runningState);
            //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
            super.context.getLiftState().run();
        }
    
        //停止状态是怎么发生的呢？当然是停止方法执行了
        @Override
        public void stop() {
        
            System.out.println("电梯停止了...");
        }
    }

//关闭状态
    public class ClosingState extends LiftState {
        
    
        @Override
        //电梯门关闭，这是关闭状态要实现的动作
        public void close() {
        
            System.out.println("电梯门关闭...");
        }
    
        //电梯门关了再打开，逗你玩呢，那这个允许呀
        @Override
        public void open() {
        
            super.context.setLiftState(Context.openningState);
            super.context.open();
        }
    
    
        //电梯门关了就跑，这是再正常不过了
        @Override
        public void run() {
        
            super.context.setLiftState(Context.runningState);
            super.context.run();
        }
    
        //电梯门关着，我就不按楼层
        @Override
        public void stop() {
        
            super.context.setLiftState(Context.stoppingState);
            super.context.stop();
        }
    }

定义环境角色类，里面定义状态对象的常量：

//环境角色
    public class Context {
        
        //定义出所有的电梯状态
        public final static OpenningState openningState = new OpenningState();//开门状态，这时候电梯只能关闭
        public final static ClosingState closeingState = new ClosingState();//关闭状态，这时候电梯可以运行、停止和开门
        public final static RunningState runningState = new RunningState();//运行状态，这时候电梯只能停止
        public final static StoppingState stoppingState = new StoppingState();//停止状态，这时候电梯可以开门、运行
    
    
        //定义一个当前电梯状态变量
        private LiftState liftState;
    
        public LiftState getLiftState() {
        
            return this.liftState;
        }
    
        public void setLiftState(LiftState liftState) {
        
            //当前环境改变
            this.liftState = liftState;
            //设置当前状态对象的Context对象（把当前的环境通知到各个实现类中）
            this.liftState.setContext(this);
        }
    
        public void open() {
        
            this.liftState.open();
        }
    
        public void close() {
        
            this.liftState.close();
        }
    
        public void run() {
        
            this.liftState.run();
        }
    
        public void stop() {
        
            this.liftState.stop();
        }
    }

写测试类看下效果：

//测试类
    public class Client {
        
        public static void main(String[] args) {
        
            Context context = new Context();
            context.setLiftState(new ClosingState());
    
            context.open();
            context.close();
            context.run();
            context.stop();
        }
    }

## 4、总结 ##

*  将状态的转换逻辑与状态对象合成一体，而不再用大块的switch或者if-else
 *  当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，考虑使用状态模式
 *  一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时，考虑使用状态模式

[b42da57b824f4ea499beb00eef2da50d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/f606f2388f914bcca9b0f0448fd7c73d.png
[4c69a9d0ad344cb384eb425cfc430b12.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/8d667061e89c4f2a961e501eb6a9af5c.png