【设计模式_青春版】行为型|状态模式

最新推荐文章于 2024-10-05 12:07:50 发布
最新推荐文章于 2024-10-05 12:07:50 发布
阅读量265 收藏
点赞数
分类专栏： Java设计模式_青春版 文章标签： java 状态模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46361305/article/details/124485535
版权
本文介绍了如何使用状态模式重构一个电梯控制系统，以解决大量switchcase和ifelse导致的代码复杂性问题。通过创建不同的状态类，如开门状态、关门状态、运行状态和停止状态，将行为与状态分离，提高了代码的可读性和扩展性。在状态模式下，每个状态类负责相应状态下的操作，使得状态转换逻辑更为清晰。
摘要由CSDN通过智能技术生成

文章目录

状态模式(行为型)

问题引入

电梯案例

一个电梯有开门状态、关门状态、停止状态、运行状态等四种状态；每一种状态改变，都有可能要根据其他状态来更新处理。例如，如果电梯门现在处于运行时状态，那么就不能进行开门操作。

初设类图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cAcP7sAj-1651157170241)(java_notes.assets/image-20220301164901559-164612454273416.png)]

ILift接口，而且它里面声明有四个常量，即OPENING_STATE、CLOSING_STATE、RUNNING_STATE、STOPPING_STATE，它们分别是来表示电梯案例中存在的四种状态的，即门开启状态、门关闭状态、运行状态和停止状态。

此外，ILift接口还提供了5个抽象方法，它们分别是：

setState(int state)：设置电梯的状态。因为我们总得记录一下当前电梯的一个状态吧！
open()：电梯开门的方法
close()：电梯关门的方法
stop()：电梯停止的方法
run()：电梯运行的方法

注意，ILift接口就是用于提高程序扩展性的，如果后期有其他的实体也需要这四种状态，那么我们完全可以让它去实现该接口。

ILift接口的子实现类，即Lift。可以看到，在该类里面定义了一个state属性，这个属性就是用来记录当前电梯状态的。除此之外，该类还重写了父接口中的所有抽象方法。

package com.meimeixia.pattern.state.before;
/**
 * 电梯接口
 */
public interface ILift {
    // 定义四个电梯状态的常量
    int OPENING_STATE = 1;
    int CLOSING_STATE = 2;
    int RUNNING_STATE = 3;
    int STOPPING_STATE = 4;
    // 设置电梯状态的功能
    void setState(int state);
    // 电梯操作功能
    void open();
    void close();
    void run();
    void stop();
}

package com.meimeixia.pattern.state.before;
/**
 * 电梯类（ILift接口的子实现类）
 */
public class Lift implements ILift {

    // 声明一个记录当前电梯状态的成员变量
    private int state;
    @Override
    public void setState(int state) {
        this.state = state;
    }

    @Override
    public void open() {
        switch (state) { // 判断当前电梯的状态
            case OPENING_STATE:
                // 如果当前电梯正处于开启状态，那么我们再去开门，这就没有任何意义了，所以这儿我们什么事都不做
                break;
            case CLOSING_STATE:
                // 如果当前电梯正处于关闭状态，那么我们就能开电梯门了
                System.out.println("电梯打开了...");
                // 设置当前电梯状态为开启状态
                setState(OPENING_STATE);
                break;
            case STOPPING_STATE:
                // 如果当前电梯正处于停止状态，那么我们也是能开电梯门的
                System.out.println("电梯打开了...");
                // 设置当前电梯状态为开启状态
                setState(OPENING_STATE);
                break;
            case RUNNING_STATE:
                // 如果当前电梯正处于运行状态，那么我们肯定是不能去开门的，因为电梯运行时是不能开门的，所以这儿我们什么事都不做
                break;
        }
    }

    @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 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;
        }
    }
}

测试

package com.meimeixia.pattern.state.before;
public class Client {

    public static void main(String[] args) {
        // 创建电梯对象
        Lift lift = new Lift();

        // 设置当前电梯的状态
        lift.setState(ILift.OPENING_STATE);

        // 打开
        lift.open();
        lift.close();
        lift.run();
        lift.stop();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nSwI3jTA-1651157170242)(java_notes.assets/image-20220301165333201-164612481414717.png)]

执行电梯的open方法去开电梯门时，你会发现并没有任何输出。

但是，现在关闭电梯门是可行的，所以在执行电梯的close方法时，你就能看到相应的输出结果了，而且此时电梯的状态就变成关闭状态了。

当电梯处于关闭状态时，你就能让电梯运行起来了，所以在执行电梯的run方法时，你就能看到相应的输出结果了，而且此时电梯的状态又变成了运行状态。

当电梯处于运行状态时，能让电梯停止吗？当然可以，所以在执行电梯的stop方法时，你就能看到相应的输出结果了，而且此时电梯的状态又变成了停止状态。

大家试想一下，如果将当前电梯的状态设置为运行状态，那么打印的结果又会是什么呢？
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tXk2H016-1651157170243)(java_notes.assets/image-20220301165504474-164612490561418.png)]

你会发现只打印了一句话，为什么会这样呢？

因为当前电梯正处于运行状态，那么此时是不允许你去开电梯门的，

那去关电梯门，可不可以呢？大可不必，因为电梯在运行过程中，本身电梯门就是关闭的，你再去关电梯门…;

那去运行电梯，可不可以呢？同样的道理。

那去让电梯停下来呢？此时就可以了，所以在执行电梯的stop方法时，你就能看到相应的输出结果了，即电梯停止了…！

系统有存在的问题：

  • 使用了大量的switch case这样的判断语句（当然了，有些人比较喜欢使用if else语句，不过效果都是一样)，使程序的可阅读性变得特别差。尤其是咱们Lift类中的方法，你会发现阅读起来体验特别特别差。

  • 扩展性很差。如果新加了断电的状态，那么我们就需要修改上面的判断逻辑。

其实，不光要修改上面的判断逻辑，我们还得在ILift接口里面定义一个表示断电状态的常量，然后再定义一个抽象的方法，接下来，在子类中还要去重写这个方法，并且对于前面已经定义好的四个方法也要进行一个修改，所以程序的扩展性是非常差的。

概述

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

一句一句来解释。

  • 开宗明义，状态模式说的是有状态的对象，所以对于没有状态的对象，你就不要使用状态模式了。

  • 然后，状态模式说的是把复杂的"判断逻辑"提取到不同的状态对象中

对于这句话，我们该如何理解呢？试想一下我们之前的做法，是不是在每一个方法里面使用switch case或者if else语句来进行判断的啊？现在使用状态模式就不同了，我们会避免使用switch case或者if else这些判断语句，而是把它们提取到不同的状态对象中，通过面向对象的形式，把同样的逻辑给实现出来。

  • 最后，状态模式说的是允许状态对象在其内部状态发生改变时改变其行为，

对于这句话，我们该如何理解呢？举例来说，在上述电梯案例中，如果当前电梯现正处于运行状态中，那么我们还能执行开门的操作吗？很显然，肯定是不可以的，这也正说明了当前电梯状态发生改变会改变其行为。

结构

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

环境（Context）角色:也称为上下文，它定义了客户程序需要的接口，维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理。

##注意，环境角色只是对外提供了一个接口，而且在它里面维护了一个当前状态，所以，具体执行操作的还是对应的当前状态对象。

抽象状态（State）角色:定义了一个接口，用以封装环境对象中的特定状态所对应的行为。

具体状态（Concrete State）角色:实现抽象状态所对应的行为。

案例再设计

分析

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7Zrspsq8-1651157170243)(java_notes.assets/image-20220301170131185-164612529246219.png)]

分析以上类图中所涉及到的类，以及类和类之间的关系了：

  • LiftState类

它充当的就是状态模式里面的抽象状态角色。在该类里面，我们声明了一个Context类型的成员变量，且它是protected修饰的，也就意味着子类可以直接去使用它了。那Context又是啥呢？它是环境角色类，在类图的最下面大家也能看到它，等一会我们再去详细说它！

  • 在LiftState类里面我们还提供了一个setContext方法

它是用来设置环境角色类对象的。除了它之外，我们还提供了四个操作电梯案例中的状态的方法，分别是open、close、stop和run等方法，而且它们都是抽象的，既然是抽象的，那就意味着要求子类必须去实现了。

  • LiftState类的四个子类，它们都是具体状态类

分别是电梯门开启状态类、电梯门关闭状态类、电梯停止状态类以及电梯运行状态类。对于这四个子类而言，它们必须去重写父类中的四个抽象方法。

  • Context类，它充当的是状态模式里面的环境角色

1、定义了四个具体状态类对象的常量，

2、定义了一个LiftState类型的成员变量：它是用来记录当前电梯状态的，并且为它我们也提供了对应的getter和setter方法。

3、还提供了open、close、stop以及run等这些方法，那你知道这些方法主要是来干嘛的吗？

看一下状态模式里面对环境角色的描述，它说的是将与状态相关的操作委托给当前状态对象来处理，所以，在Context类的open、close、stop以及run这些方法里面，到时候就会去调用当前状态对象里面对应的方法了。

Context 里 包含了抽象状态角色以聚合具体状态角色，以表示当前状态， 也包含了其他所有的具体状态角色且是常量，方便后续根据当前状态去调用对应的状态对象的方法

Context 聚合在状态角色类中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ts32OlPq-1651157170244)(java_notes.assets/image-20220301173203238-164612712447520.png)]

代码实现

创建抽象状态类，即LiftState。

package com.meimeixia.pattern.state.after;
/**
 * 抽象状态类
 */
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();

}

创建四个具体状态类。这里，先创建电梯开启状态类，即OpeningState。

package com.meimeixia.pattern.state.after;
/**
 * 电梯开启状态类
 */
public class OpeningState extends LiftState {
    /**
     * 当前状态下要执行的方法
     *
     * 因为当前电梯本身就处于开启状态，所以open方法就是当前电梯在开启状态下要执行的方法
     */
    @Override
    public void open() {
        System.out.println("电梯开启...");
    }
    /**
     * 当电梯处于开启状态时，我们是可以关闭电梯门的
     */
    @Override
    public void close() {
        // 修改状态
        super.context.setLiftState(Context.CLOSING_STATE); // 记录当前电梯的状态
        // 调用当前电梯状态对象中的Context对象中的close方法。记住，此时调用的是电梯关闭状态对象中的close方法
        super.context.close();
    }
    /**
     * 电梯门不能开着就跑，所以这里我们什么也不做
     */
    @Override
    public void run() {
        // 什么都不做
    }
    /**
     * 电梯处于开启状态时，它本身就是停止的了，所以这里我们什么也不做
     */
    @Override
    public void stop() {
        // 什么都不做
    }
   
}

创建的具体状态类，RunningState，代码如下所示。

package com.meimeixia.pattern.state.after;
/**
 * 电梯运行状态类
 */
public class RunningState extends LiftState {
    /**
     * 电梯运行的时候开电梯门？你疯了吗！电梯它不会给你开的，所以这里我们什么也不做
     */
    @Override
    public void open() {
        // do nothing
    }
    /**
     * 当电梯处于运行状态时，电梯门本身就是关闭的，所以这里我们什么也不做
     */
    @Override
    public void close() {
        // do nothing
    }
    /**
     * 当前状态下要执行的方法
     *
     * 因为当前电梯本身就处于运行状态，所以run方法就是当前电梯在运行状态下要执行的方法
     */
    @Override
    public void run() {
        System.out.println("电梯正在运行...");
    }
    /**
     * 这个事绝对是合理的，电梯光运行不停止，那还有谁敢坐这个电梯啊？估计只有上帝了
     */
    @Override
    public void stop() {
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.stop();
    }

}

package com.meimeixia.pattern.state.after;
/**
 * 电梯停止状态类
 */
public class StoppingState extends LiftState {
    /**
     * 当电梯处于停止状态时，我们是可以开电梯门的
     */
    @Override
    public void open() {
        // 状态修改
        super.context.setLiftState(Context.OPENING_STATE);
        /*
         * 委托给OpeningState类来执行开电梯门这个动作
         *
         * 当然了，以下代码你也可以替换为：super.context.open();
         */
        super.context.getLiftState().open();
    }
    /**
     * 当电梯处于停止状态时，我们也是可以关电梯门的
     */
    @Override
    public void close() {
        // 状态修改
        super.context.setLiftState(Context.CLOSING_STATE);
        /*
         * 委托给ClosingState类来执行关电梯门这个动作
         *
         * 当然了，以下代码你也可以替换为：super.context.close();
         */
        super.context.getLiftState().close();
    }
    /**
     * 电梯由停止状态再跑起来，正常的很
     */
    @Override
    public void run() {
        // 状态修改
        super.context.setLiftState(Context.RUNNING_STATE);
        /*
         * 委托给RunningState类来执行运行电梯这个动作
         *
         * 当然了，以下代码你也可以替换为：super.context.run();
         */
        super.context.getLiftState().run();
    }

    /**
     * 当前状态下要执行的方法
     *
     * 因为当前电梯本身就处于停止状态，所以stop方法就是当前电梯在停止状态下要执行的方法
     */
    @Override
    public void stop() {
        System.out.println("电梯停止了...");
    }

}

package com.meimeixia.pattern.state.after;

/**
 * 电梯门关闭状态类
 */
public class ClosingState extends LiftState {

    /**
     * 当前状态下要执行的方法
     *
     * 因为当前电梯本身就处于关闭状态，所以close方法就是当前电梯在关闭状态下要执行的方法
     */
    @Override
    public void close() {
        System.out.println("电梯门关闭...");
    }
    /**
     * 电梯门关了再打开，这是允许的
     */
    @Override
    public void open() {
        super.context.setLiftState(Context.OPENING_STATE);
        super.context.open();
    }
    /**
     * 电梯门关了就跑，这是再正常不过的了
     */
    @Override
    public void run() {
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.run();
    }
    /**
     * 电梯门关着，我就是不按楼层，你能怎么着我
     */
    @Override
    public void stop() {
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.stop();
    }

}

package com.meimeixia.pattern.state.after;
/**
 * 电梯门开启状态类
 */
public class OpeningState extends LiftState {

    /**
     * 当前状态下要执行的方法
     *
     * 因为当前电梯本身就处于开启状态，所以open方法就是当前电梯在开启状态下要执行的方法
     */
    @Override
    public void open() {
        System.out.println("电梯开启...");
    }
    /**
     * 当电梯处于开启状态时，我们是可以关闭电梯门的
     */
    @Override
    public void close() {
        // 修改状态
        super.context.setLiftState(Context.CLOSING_STATE); // 记录当前电梯的状态
        // 调用当前电梯状态对象中的Context对象中的close方法。记住，此时调用的是电梯关闭状态对象中的close方法
        super.context.close();
    }
    /**
     * 电梯门不能开着就跑，所以这里我们什么也不做
     */
    @Override
    public void run() {
        // 什么都不做
    }
    /**
     * 电梯处于开启状态时，它本身就是停止的了，所以这里我们什么也不做
     */
    @Override
    public void stop() {
        // 什么都不做
    }
   
}

以上四个具体状态类创建完毕之后，接下来，我们来创建环境角色类，即Context。

package com.meimeixia.pattern.state.after;
/**
 * 环境角色类
 */
public class Context {

    // 定义对应电梯状态类对象的常量
    public final static OpeningState OPENING_STATE = new OpeningState();
    public final static ClosingState CLOSING_STATE = new ClosingState();
    public final static RunningState RUNNING_STATE = new RunningState();
    public final static StoppingState STOPPING_STATE = new StoppingState();

    // 定义一个记录当前电梯状态的变量
    private LiftState liftState;

    public LiftState getLiftState() {
        return liftState;
    }

    // 设置当前电梯状态对象
    public void setLiftState(LiftState liftState) {
        this.liftState = liftState;
        // 设置完当前电梯状态对象之后，别忘了，我们还得设置当前电梯状态对象中的Context对象
        this.liftState.setContext(this); // 现在我们就在Context类中，所以在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();
    }

}

测试类

package com.meimeixia.pattern.state.after;

public class Client {
    public static void main(String[] args) {
        // 创建环境角色对象，因为我们之前就已经说过，环境角色就是对外提供访问的接口
        Context context = new Context();
        // 设置当前电梯状态
        context.setLiftState(new RunningState());

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

大脑调试运行：

context 设置 当前状态并将当前状态对象的环境Context设置为当前环境context，context调用函数，而这些函数又调用当前对象的方法，在这些方法中，会实现相印的功能，也会改变环境的当前状态、

优缺点

优点

关于状态模式的优点，我总结出了下面两点。

  • 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。

  • 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。

在未使用状态模式改进的电梯案例中，我们就大量使用到了switch case或者if else这样的语句，这就不是面向对象的思想，而使用了状态模式之后，是不是更加面向对象了啊！此外，它还允许将状态转换逻辑和状态对象合为一体，这不是一举两得吗？

缺点

关于状态模式的优点，我总结出了下面三点。

  • 状态模式的使用必然会增加系统类和对象的个数。

在未使用状态模式改进的电梯案例中，其实也就创建了一个接口和一个类，而使用了状态模式进行了改进之后，你会发现有多少个状态就要创建多少个状态类，这样，类肯定是增加了，类增加了之后，那么相应的对象的个数肯定也会增加。

  • 状态模式的结构与实现都较为复杂，如果使用不当，那么就会导致程序结构和代码的混乱。

看一下咱们使用状态模式改进之后的电梯案例，在抽象状态类（即LiftState）里面就聚合了Context类的对象，而在Context类里面，你会发现又聚合了LiftState类的对象，所以程序的结构还是比较复杂的，这样的话，我们在设计的时候就一定要加倍小心了。

  • 状态模式对"开闭原则"的支持并不太好。

你想啊，后期如果我们想要添加一个新的状态，那么我们不光要添加一个新的状态类，还要去修改Context类里面的代码，并且对于那些具体状态类的代码我们也要稍微进行一个修改，所以我们才说状态模式对开闭原则的支持并不是特别好。

使用场景

只要出现如下几个场景，我们就可以去考虑一下能不能使用状态模式了。

  • 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式了。

状态模式主要体现的就是状态，只要一个对象的行为取决于它的状态（状态不一样，对象的行为也会不一样），那么这个时候你就可以考虑使用状态模式了。

  • 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。

也就是说，如果你写的代码里面大量地运用到了switch case或者if else语句，那么这个时候你就不妨试试使用状态模式。

甲粒子
关注
专栏目录
C语言 switch语句举例说明（类比坐电梯来理解）
看花容易绣花难
12-19 2万+
我们把**使用switch语句的过程规律**想象成坐**电梯**（大家都有坐电梯的经历），每个**case语句**后面的标号相当于一个**按钮**，你要在哪一层下去，就按那一层按钮，就可以在这一层下去。
C语言switch选择结构
热门推荐
SqrsCbrOnly1的博客
06-10 2万+
一、switch的思想及意义： 程序设计中选择结构的第二大语句就是：switch语句。switch和if—else if一样都可以做多分支选择，但是switch语句的思想是把程序所有可能出现的值 的情况，列出一个情况表，根据所输入的值判断与情况表中的的那种情况相同，直接执行相应情况下的语句即可。可直接处理相对应的数据流，加快执行速度。 switch语句之所以被称为开关语句，因为它就类似于生活中人们...
【设计模式_青春版】行为型|模板方法模式
weixin_46361305的博客
03-30 423
【设计模式_青春版】行为型|模板方法模式
Qt与设计模式(全)
Funning的博客
10-27 1万+
为什么要学习设计模式？创建型模式工厂模式（Factory Pattern）抽象工厂模式（Abstract Factory Pattern）单例模式（Singleton Pattern）建造者模式（Builder Pattern）原型模式（Prototype Pattern）结构型模式适配器模式（Adapter Pattern）桥接模式（Bridge Pattern）过滤器模式（Filt...
C++设计模式 | 四种行为型模式——模版方法模式、策略模式、命令模式、观察者模式...
weixin_41017788的博客
02-16 418
模版方法模式 定义一个操作中算法的框架，而将一些步骤延迟到子类中。模板方法模式使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 AbstractClass（抽象类）：在抽象类中定义了一系列基本操作，这些基本操作可以是具体的，也可以是抽象的，每一个基本操作对应算法的一个步骤，在其子类中可以重定义或实现这些步骤。同时，在抽象类中实现了一个模板方法(Temp...
Java面试题-设计模式23（2024最新版），2024年最新二叉树 面试题
sili7762mo的博客
04-18 431
小编也是很有感触，如果一直都是在中小公司，没有接触过大型的互联网架构设计的话，只靠自己看书去提升可能一辈子都很难达到高级架构师的技术和认知高度。向厉害的人去学习是最有效减少时间摸索、精力浪费的方式。我们选择的这个行业就一直要持续的学习，又很吃青春饭。虽然大家可能经常见到说程序员年薪几十万，但这样的人毕竟不是大部份，要么是有名校光环，要么是在阿里华为这样的大企业。年龄一大，更有可能被裁。送给每一位想学习Java小伙伴，用来提升自己。
设计模式及C++实现
Shawn的博客
03-28 1032
设计模式及C++实现类设计的原则1. 开闭原则2. 里氏替换原则3. 依赖倒置原则4. 单一职责原则5. 接口隔离原则6. 迪米特法则创建性模式结构型模式行为型模式 类设计的原则 1. 开闭原则 含义: 软件实体对扩展开放,对修改关闭 实现: 具体类实现抽象类 2. 里氏替换原则 含义: 所有引用基类的地方都可以透明的使用其子类,即父类的对象均可用子类对象替代,不会出现任何错误或异常,反过来...
设计模式
更上一层楼！
03-22 1068
六大原则 追根溯源，六大原则都有一个同样的理念：对拓展开放，对修改封闭。 然后根据这一个理念衍生出6个原则： 单一职责原则 一个类应该只实现单一职责，不能既当爹又当妈，一定可以找到合适的分界，对实现了多个职责的类进行拆分。 里式替换原则 所有引用基类的地方必须能透明地使用其子类的对象。 按我的理解就是子类继承父类后，不应该改变父类的职责，尽量不要复写父类同名方法，基类代表了定义好的结构，通过这个...
设计模式(四)--结构类模式
Hu_yilang的博客
04-26 296
1.设计之禅：https://www.kancloud.cn/sstd521/design/193529 2.本文引用博客：https://blog.csdn.net/zhengzhb/article/category/926691 3.图解设计模式；https://design-patterns.readthedocs.io/zh_CN/latest/structural_patterns/...
河北省临西县第学七年级政治下册 2.1 我能行教学设计2 新人教版.doc
11-19
这篇教学设计针对的是河北省临西县七年级的政治课程，主题为"我能行"，源自新人教版七年级思想品德下册第一单元《做自尊自信的人》的第二课《扬起自信的风帆》。设计旨在帮助初中生建立正确的自我认知，培养他们的...
python毕业设计总结范文大全_关于毕业设计总结范文
weixin_39820244的博客
12-20 1813
毕业设计是我们作为学生在学习阶段的最后一个环节,是对所学基础知识和专业知识的一种综合应用,是一种综合的再学习，再提高的过程.下面是小编整理的毕业设计总结，希望大家有所收获。第1篇:毕业设计总结经过一段时间努力，毕业设计总体功能总算完成了，虽然上个学期交了一稿，但系统的有些功能还是没有完成，这个学期开始又一直在外面，没有时间做，四月份回学校以后总算有时间来完成它了。我选的毕业设计是基于ASP.NET...
蒙特卡罗树搜索
AI天才研究院
08-06 735
蒙特卡罗树搜索（Monte Carlo Tree Search, MCTS）是一种用于对复杂决策问题进行快速、准确搜索的方法。它被广泛应用于游戏AI、自动驾驶、网络安全等领域。本文主要基于作者在自然语言处理领域的经验和学习，系统性地回顾了蒙特卡罗树搜索（MCTS）的基本原理和最新进展。希望能为读者提供一个系统性的学习参考。本文简要回顾了蒙特卡罗树搜索的基本原理、算法、应用及局限性，并阐述了MCTS的基本概念和运作方式。
底部标签导航有哪些设计形式？来看这篇超全总结！
我的ID：sumer-work（全网同名）昵称：程序员SUMER（全网同名）
06-26 65
对于 UI 设计师来说，产品体验是一种习惯的养成，结合体验的日记化摘录形成设计思路的总结。总结是为了形成最终可供灵感借鉴的经验，基于优秀的案例分析才能形成更多的设计解决方案。本文以移动端底部标签栏导航设计的经验分析为大家进行梳理，任何的设计表达都不是不变的规律，掌握的是这种设计分析和总结的思路，以此反推出更多的设计总结。希望本文的思路作为抛砖引玉，带给你更多的思路。
C语言 | 第十章 | 函数 作用域
最新发布
ZJC744575的博客
10-05 914
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 440
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 835
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
java将word转pdf
紫月7575的博客
09-30 527
java将word转pdf
spring-boot 整合 mybatis
m0_72168501的博客
09-29 547
spring boot 整合 mybatis
行为型模式：11种经典设计模式详解
在行为型模式中，有11种常见的设计模式，包括职责链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式和访问者模式。 1. **职责链模式**：动机在于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值