状态模式（Java行为型设计模式）

于 2022-01-25 18:08:30 发布
阅读量211 收藏 1
点赞数 2
分类专栏： Java设计模式 文章标签： 状态模式 java 开发语言 设计模式 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JavaBoy_XZL/article/details/122689844
版权

概述

【例】通过按钮来控制一个电梯的状态，一个电梯有开门状态，关门状态，停止状态，运行状态。每一种状态改变，都有可能要根据其他状态来更新处理。例如，如果电梯门现在处于运行时状态，就不能进行开门操作，而如果电梯门是停止状态，就可以执行开门操作。

类图如下：

 代码如下：

//电梯接口
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也是一样)，使程序的可阅读性变差。
* 扩展性很差。如果新加了断电的状态，我们需要修改上面判断逻辑

定义：

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

结构

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

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

案例实现

对上述电梯的案例使用状态模式进行改进。类图如下：

 代码如下：

/**
 * @author: xuzhilei
 * @create: 2022-01-21
 * @description: 电梯抽象状态类
 **/
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();
}
/**
 * @author: xuzhilei
 * @create: 2022-01-21
 * @description: 环境角色类
 **/
public class Context {
    /**
     * 开门状态，这时候电梯只能关闭
     */
    public static final OpenningState OPENNING_STATE = new OpenningState();
    /**
     * 关闭状态，这时候电梯可以运行、停止和开门
     */
    public static final ClosingState CLOSEING_STATE = new ClosingState();
    /**
     * 运行状态，这时候电梯只能停止
     */
    public static final RunningState RUNNING_STATE = new RunningState();
    /**
     * 停止状态，这时候电梯可以开门、运行
     */
    public static final StoppingState STOPPING_STATE = new StoppingState();

    /**
     * 持有一个电梯状态对象引用
     */
    private LiftState state;

    public LiftState getState() {
        return this.state;
    }

    public void setState(LiftState state) {
        this.state = state;
        this.getState().setContext(this);
    }
    public void open() {
        this.state.open();
    }
    public void close() {
        this.state.close();
    }
    public void run() {
        this.state.run();
    }
    public void stop() {
        this.state.stop();
    }
    
}
/**
 * @author: xuzhilei6656
 * @create: 2022-01-21 18:23
 * @description: 电梯门开启状态类
 **/
public class OpenningState extends LiftState{

    /**
     * 此时电梯门就是开启状态
     */
    @Override
    public void open() {
    }

    /**
     * 此时开着门，当然可以执行关门动作
     */
    @Override
    public void close() {
        System.out.println("电梯门关闭");
        //切换到关闭状态
        this.context.setState(Context.CLOSEING_STATE);
    }

    /**
     * 电梯门开着，不能运行
     */
    @Override
    public void run() {

    }

    /**
     * 电梯门开着，已经处于停止状态
     */
    @Override
    public void stop() {

    }
}
/**
 * @author: xuzhilei6656
 * @create: 2022-01-21 18:29
 * @description: 电梯门关闭状态类
 **/
public class ClosingState extends LiftState {

    /**
     * 单电梯门处于关闭状态，可以执行开门操作
     */
    @Override
    public void open() {
        System.out.println("电梯门开了");
        //切换到开启状态
        this.context.setState(Context.OPENNING_STATE);
    }

    /**
     * 电梯门此时就是处于关闭状态，什么也不做
     */
    @Override
    public void close() {

    }

    /**
     * 电梯门关着，可以执行运行状态
     */
    @Override
    public void run() {
        System.out.println("电梯启动了");
        //切换到运行状态
        this.context.setState(Context.RUNNING_STATE);
    }

    /**
     * 电梯门关着，可以执行停止操作
     */
    @Override
    public void stop() {
        System.out.println("电梯停止了");
        //切换到停止状态
        this.context.setState(Context.STOPPING_STATE);
    }
}
/**
 * @author: xuzhilei6656
 * @create: 2022-01-21 18:31
 * @description: 电梯运行状态类
 **/
public class RunningState extends LiftState{

    /**
     * 电梯处于运行时，不能开门
     */
    @Override
    public void open() {

    }

    /**
     * 电梯处于运行时，门就是关着的，什么也不做
     */
    @Override
    public void close() {

    }

    /**
     * 电梯此时就是处于运行状态，什么也不做
     */
    @Override
    public void run() {

    }

    /**
     * 电梯处于运行时，可以执行停止操作
     */
    @Override
    public void stop() {
        System.out.println("电梯停止了");
        //切换到停止状态
        this.context.setState(Context.STOPPING_STATE);
    }
}
/**
 * @author: xuzhilei6656
 * @create: 2022-01-21 18:32
 * @description: 电梯停止状态类
 **/
public class StoppingState extends LiftState{
    /**
     * 电梯处于停止状态，可以执行开门操作
     */
    @Override
    public void open() {
        System.out.println("电梯开门了");
        //切换到门开启状态
        this.context.setState(Context.OPENNING_STATE);
    }

    /**
     * 电梯处于停止状态，可以执行关门操作
     */
    @Override
    public void close() {
        System.out.println("电梯门关了");
        //切换到门关闭状态
        this.context.setState(Context.CLOSEING_STATE);
    }

    /**
     * 电梯处于停止状态，可以执行运行操作
     */
    @Override
    public void run() {
        System.out.println("电梯启动了");
        //切换到运行状态
        this.context.setState(Context.RUNNING_STATE);
    }

    /**
     * 此时本来就是停止状态，什么也不做
     */
    @Override
    public void stop() {

    }
}
/**
 * @author: xuzhilei6656
 * @create: 2022-01-21 19:03
 * @description: 测试
 **/
public class Client {
    public static void main(String[] args) {
        //创建环境对象
        Context context = new Context();
        context.setState(Context.STOPPING_STATE);

        context.open();
        context.close();
        context.run();
        context.stop();
    }
}

测试结果：

优缺点

1，优点：

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

2，缺点：

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

使用场景

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

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值