Java 23种设计模式（17.行为型模式-状态模式）

浅浅的花香味﹌ 2023-09-23 23:53 95阅读 0赞

> # 行为型模式-`状态模式` #

# 代码解析 #

## 类图 ##

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

## 代码 ##

abstract class State {
        
        public abstract void Handle(Context context);
    
    }

public class Context {
        
        private State state;
        public final static ConcreteStateA A = new ConcreteStateA();
        public final static ConcreteStateB B = new ConcreteStateB();
    
        public Context(State state) {
        
            this.state = state;
        }
    
        public State getState() {
        
            return state;
        }
    
        public void setState(State state) {
        
            this.state = state;
        }
    
        public void request(){
        
            state.Handle(this);
        }
    }

public class ConcreteStateA extends State {
        
        @Override
        public void Handle(Context context) {
        
            System.out.println("ConcreteStateA is doing");
            context.setState(Context.B);
    
        }
    }

public class ConcreteStateB extends State {
        
        @Override
        public void Handle(Context context) {
        
            System.out.println("ConcreteStateB is doing");
            context.setState(Context.A);
    
        }
    }

public class Client {
        
        public static void main(String[] args) {
        
            State s = new ConcreteStateA();
            Context context = new Context(s);
    
            context.request();
            context.request();
            context.request();
        }
    
    }

## 运行结果 ##

ConcreteStateA is doing
    ConcreteStateB is doing
    ConcreteStateA is doing

# 1.概述 #

【例】通过按钮来控制一个电梯的状态，一个电梯有开门状态，关门状态，停止状态，运行状态。每一种状态改变，都有可能要根据其他状态来更新处理。例如，如果电梯门现在处于运行时状态，就不能进行开门操作，而如果电梯门是停止状态，就可以执行开门操作。  
![在这里插入图片描述][c913e6aa3eb34928a3ccb80245eb0408.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这样的判断（if…else也是一样)，使程序的可阅读性变差。  
扩展性很差。如果新加了断电的状态，我们需要修改上面判断逻辑

**定义：**  
对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，**允许状态对象在其内部状态发生改变时改变其行为**。

# 2.结构 #

状态模式包含以下主要角色。

`环境（Context）角色`：也称为上下文，它**定义了客户程序需要的接口，维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理。**  
`抽象状态（State）角色`：定义一个接口，**用以封装环境对象中的特定状态所对应的行为。**  
`具体状态（Concrete State）角色`：实**现抽象状态所对应的行为。**

# 3.类图 #

对上述电梯的案例使用状态模式进行改进。类图如下：  
![在这里插入图片描述][91d0e0d3417547abb4fa76a27a61104b.png]

# 4.代码 #

abstract class LiftState {
        
        //声明环境角色类变量
        public Context context;
    
    
        public Context getContext() {
        
            return context;
        }
    
        public void setContext(Context context) {
        
            this.context = context;
        }
    
        //电梯开启操作
        abstract void open();
        //电梯关闭操作
        abstract void close();
        //电梯运行操作
        abstract void stop();
        //电梯停止操作
        abstract void run();
    
    }

public class Context {
        
        //定义对应状态对象的常量
        public final static OpeningState openingState = new OpeningState();
        public final static ClosingState closingState = new ClosingState();
        public final static RunningState runningState = new RunningState();
        public final static StoppingState stoppingState = new StoppingState();
    
        //定义一个当前电梯状态变量
        private LiftState liftState;
    
        public LiftState getLiftState() {
        
            return liftState;
        }
        //设置当前状态对象
        public void setLiftState(LiftState liftState) {
        
            this.liftState = liftState;
            this.liftState.setContext(this);
        }
        public void open(){
        
            this.liftState.open();
        }
        public void close(){
        
            this.liftState.close();
    
        }
        public void stop(){
        
            this.liftState.stop();
    
        }
        public void run(){
        
            this.liftState.run();
    
        }
    }

public class OpeningState extends LiftState{
        
        //当前状态要执行的方法
        @Override
        public void open() {
        
            System.out.println("it is opening");
        }
    
        @Override
       public void close() {
        
            //修改状态
            super.context.setLiftState(closingState);
            //调用当前状态中的context中的close方法
            super.context.close();
        }
    
        @Override
        public void stop() {
        
            //do nothing
    
        }
    
        @Override
       public void run() {
        
            //do nothing
        }
    }

public class ClosingState extends LiftState{
        
        @Override
        public void close() {
        
            System.out.println("it is closing");
    
        }
    
        @Override
        public void open() {
        
            super.context.setLiftState(openingState);
            super.context.open();
        }
        @Override
        public void run() {
        
            super.context.setLiftState(runningState);
            super.context.run();
    
        }
        //当前状态要执行的方法
    
        @Override
        public void stop() {
        
            super.context.setLiftState(stoppingState);
            super.context.stop();
    
        }
    
    
    }

public class RunningState extends LiftState{
        
        @Override
        public void run() {
        
            System.out.println("it is running");
    
        }
        @Override
        public void close() {
        
            //do nothing
        }
        @Override
        public void open() {
        
            //do nothing
        }
        @Override
        public void stop() {
        
            super.context.setLiftState(stoppingState);
            super.context.stop();
    
        }
    
    }

public class StoppingState extends LiftState{
        
        @Override
        public void stop() {
        
            System.out.println("it is stopping");
        }
        @Override
        public void run() {
        
            super.context.setLiftState(runningState);
            super.context.run();
        }
        @Override
        public void close() {
        
            super.context.setLiftState(closingState);
            super.context.close();
        }
        @Override
        public void open() {
        
            super.context.setLiftState(openingState);
            super.context.open();
        }
    }

public class Client {
        
        public static void main(String[] args) {
        
            //创建环境角色对象
            Context context = new Context();
            //设置当前电梯装填
            context.setLiftState(new ClosingState());
             context.open();
             context.run();
             context.close();
             context.stop();
        }
    }

it is opening
    it is closing
    it is stopping

# 5.优缺点 #

**优点：**

*  **将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。**
 *  允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。

**缺点：**

*  **状态模式的使用必然会增加系统类和对象的个数**。
 *  状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。
 *  状态模式对"开闭原则"的支持并不太好。

# 6. 使用场景 #

*  **当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。**
 *  一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。

[3287ce980b214b2facb6b6128faba89e.png]: https://img-blog.csdnimg.cn/3287ce980b214b2facb6b6128faba89e.png
[c913e6aa3eb34928a3ccb80245eb0408.png]: https://img-blog.csdnimg.cn/c913e6aa3eb34928a3ccb80245eb0408.png
[91d0e0d3417547abb4fa76a27a61104b.png]: https://img-blog.csdnimg.cn/91d0e0d3417547abb4fa76a27a61104b.png