厚积薄发打卡Day44: [itcast]GoF23通俗易懂的设计模式之＜状态模式＞

最新推荐文章于 2021-07-31 23:32:06 发布

coolgwayne

最新推荐文章于 2021-07-31 23:32:06 发布

阅读量76

点赞数

分类专栏：黑马学习 Java基础进阶设计模式文章标签：设计模式 java

本文链接：https://blog.csdn.net/qq_42191980/article/details/115280911

版权

Java基础进阶同时被 3 个专栏收录

37 篇文章 2 订阅

订阅专栏

设计模式

23 篇文章 0 订阅

订阅专栏

黑马学习

19 篇文章 0 订阅

订阅专栏

前言：

视频教程：黑马程序员Java设计模式详解，全网最全23种Java设计模式

什么是设计模式？

设计模式(Design Pattern)是前辈们对代码开发经验的总结，是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。
1995年，GoF(Gang of Four,四人组)合作出版了《设计模式：可复用面向对象软件的基础》一书，共收录了23种设计模式，人称【GoF设计模式】

设计模式分类具体模式
创建型模式：
它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度，使用者不需要关注对象的创建细节。 ⌛单例模式、⌛工厂模式、⌛抽象工厂模式、⌛建造者模式、⌛原型模式
结构型模式:
结构型模式描述如何将类或对象按某种布局组成更大的结构。 ⌛适配器模式、⌛桥接模式、⌛装饰模式、⌛代理模式、⌛外观模式、⌛组合模式、⌛享元模式、
行为型模式:
这些设计模式特别关注对象之间的通信。 ⌛模板方法模、⌛策略模式、⌛命令模式、⌛职责链模式、⌛状态模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、访问者模式

设计模式分类	具体模式
创建型模式：它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度，使用者不需要关注对象的创建细节。	⌛单例模式、⌛工厂模式、⌛抽象工厂模式、⌛建造者模式、⌛原型模式
结构型模式: 结构型模式描述如何将类或对象按某种布局组成更大的结构。	⌛适配器模式、⌛桥接模式、⌛装饰模式、⌛代理模式、⌛外观模式、⌛组合模式、⌛享元模式、
行为型模式: 这些设计模式特别关注对象之间的通信。	⌛模板方法模、⌛策略模式、⌛命令模式、⌛职责链模式、⌛状态模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、访问者模式

状态模式

状态模式(State)：

当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类.[DP]

概述

【状态模式】

主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断
逻辑转移到表示不同状态的一系列类当中，允许状态对象在其内部状态发生改变时改变其行为，可以把复杂的判断逻辑简化。

当然，如果这个状态判断很简单，那就没必要用“状态模式“了。

结构：

在这里插入图片描述

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

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

实例

【电梯运行案例】

通过按钮来控制一个电梯的状态，一个电梯有

开门状态
关门状态
停止状态
运行状态。

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

运用状态模式之前：

在这里插入图片描述

电梯接口：

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();
}

电梯实体类：此时需要大量的if–else判断

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 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来执行：
        super.context.getLiftState().close();
    }

    @Override
    public void run() {
        System.out.println("----:do nothing门开着不能走，你是不是傻");
    }

    @Override
    public void stop() {
        System.out.println("----:do nothing电梯已经是停着的了，你想干啥");
    }
}

关闭

public class ClosingState extends LiftState {

    @Override
    //电梯门关闭，这是关闭状态要实现的动作
    public void close() {
        System.out.println("电梯门关闭...");
    }

    //电梯门关了再打开，逗你玩呢，那这个允许呀
    @Override
    public void open() {
        super.context.setLiftState(Context.openningState);
        super.context.getLiftState().open();
    }


    //电梯门关了就跑，这是再正常不过了
    @Override
    public void run() {
        super.context.setLiftState(Context.runningState);
        super.context.getLiftState().run();
    }

    //电梯门关着，我就不按楼层
    @Override
    public void stop() {
        super.context.setLiftState(Context.stoppingState);
        super.context.getLiftState().stop();
    }
}

运行

public class RunningState extends LiftState {

    @Override
    public void open() {
        System.out.println("----:do nothing运行的时候开电梯门？你疯了！电梯不会给你开的");
    }

    @Override
    public void close() {
        System.out.println("----:do nothing电梯门关闭？这是肯定了");
    }

    @Override
    public void run() {
        System.out.println("电梯正在运行...");
    }

    //这个事绝对是合理的，光运行不停止还有谁敢做这个电梯？！估计只有上帝了
    @Override
    public void stop() {
        //把运行中的电梯停了
        super.context.setLiftState(Context.stoppingState);
        super.context.getLiftState().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 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 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 run() {
        this.liftState.run();
    }

    public void stop() {
        this.liftState.stop();
    }
}

用户坐电梯：

小结

优缺点：

优点：

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

缺点：

状态模式的使用必然会增加系统类和对象的个数。
状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。
状态模式对"开闭原则"的支持并不太好。
- 在对电梯的例子是用状态模式之后反而感觉更加累赘。

使用场景

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

应用场景

跟着视频把实例撸了一遍之后，发现这种设计模式确实有点麻烦。怪不得搜索实例应用基本没有找到框架中的应用。在此跳过吧😂

coolgwayne

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
厚积薄发打卡Day44: [itcast]GoF23通俗易懂的设计模式之＜状态模式＞

前言：视频教程：黑马程序员Java设计模式详解，全网最全23种Java设计模式什么是设计模式？设计模式(Design Pattern)是前辈们对代码开发经验的总结，是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。1995年，GoF(Gang of Four,四人组)合作出版了《设计模式：可复用面向对象软件的基础》一书，共收录了23种设计模式，人称【GoF设计模式】设计模式分类具体模式创建型模式：它的主要特点是“将对象的创建与使用分离”。这样可
复制链接

扫一扫