设计模式之禅【状态模式】

最新推荐文章于 2024-08-06 16:21:17 发布
最新推荐文章于 2024-08-06 16:21:17 发布
阅读量534 收藏
点赞数
分类专栏： 设计模式专栏 设计模式之禅
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eieiei438/article/details/79044549
版权

真刀实枪之状态模式

  • 从电梯说起

    • 随着城市的发展，有两样东西的发明在城市的发展中起到非常重要的作用
      1. 汽车：横向发展
      2. 电梯：纵向发展
    • 既然说电梯，那就看看电梯有哪些动作
      1. 开门
      2. 关门
      3. 运行
      4. 停止
    • 好了，动作有了，设计下类图

    • 类图比较通俗易懂，那么先来实现一下，看看有什么问题

      • ILift

        package com.peng.zt;

/**
 * @author kungfu~peng
 * @data 2017年11月28日
 * @description
 */
public interface ILift {
    // 电梯开启
    public void open();

    // 电梯关闭
    public void close();

    // 电梯运行
    public void run();

    // 电梯停止
    public void stop();
}

      • Lift

        package com.peng.zt;

/**
 * @author kungfu~peng
 * @data 2017年11月28日
 * @description
 */
public class Lift implements ILift {
    // 电梯关闭
    @Override
    public void open() {
        System.out.println("电梯开启~~");
    }

    // 电梯关闭
    @Override
    public void close() {
        System.out.println("电梯关闭~~");
    }

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

    // 电梯停止
    @Override
    public void stop() {
        System.out.println("电梯停止~~");
    }

}

      • Client

        package com.peng.zt;

/**
 * @author kungfu~peng
 * @data 2017年11月28日
 * @description
 */
public class Client {
    public static void main(String[] args) {
        ILift lift = new Lift();
        // 人来了，开启电梯
        System.out.println("人来了：");
        lift.open();
        // 然后电梯门关闭
        lift.close();
        // 然后让电梯运行起来
        lift.run();
        // 最后人到达目的地，停止电梯
        lift.stop();
        System.out.println("人到达楼层。");
    }
}

      • 执行结果

        人来了：
电梯开启~~
电梯关闭~~
电梯运行~~
电梯停止~~
人到达楼层。
  • 看到这个程序，是不是有点太简单~~非也非也，继续往下，这个程序有什么问题？
    1. 电梯门可以打开，但是不能随便打开吧！
    2. 电梯执行这四个动作应该都有前提条件，在特定的条件下才能做特定的动作
  • 为了解决这些暂时能想到的问题，先来分析电梯有哪些特定的状态
    • 敞门状态：这个状态下，电梯能做的就是关门动作
    • 闭门状态：这个状态下，电梯可以开门、停止、运行
    • 运行状态：这个状态下，电梯只能停止
    • 停止状态：这个状态下，电梯能做运行和开门动作
  • 电梯的状态和动作之间的关系下图来演示：

  • 有了这个前提，那我们的代码中的方法执行前就得有前置条件的判断了，只有满足相应条件才能进行相应的动作

    • 先改类图

    • 代码改动

      • ILift

        package com.peng.zt;

/**
 * @author kungfu~peng
 * @data 2017年11月28日
 * @description
 */
public interface ILift {
    public static final int OPENING_STATE = 1;// 敞门状态
    public static final int CLOSING_STATE = 2;// 闭门状态
    public static final int RUNNING_STATE = 3;// 运行状态
    public static final int STOPPING_STATE = 4;// 停止状态

    // 设置电梯的状态
    public void setState(int state);

    // 电梯开启
    public void open();

    // 电梯关闭
    public void close();

    // 电梯运行
    public void run();

    // 电梯停止
    public void stop();
}

      • LIft

        package com.peng.zt;

/**
 * @author kungfu~peng
 * @data 2017年11月28日
 * @description
 */
public class Lift implements ILift {
    private int state;// 电梯的状态

    // 设置电梯的状态
    @Override
    public void setState(int state) {
        this.state = state;
    }

    /* 无逻辑的电梯执行方法 */
    // 电梯关闭
    private void openWithoutLogic() {
        System.out.println("电梯开启~~");
    }

    // 电梯关闭
    private void closeWithoutLogic() {
        System.out.println("电梯关闭~~");
    }

    // 电梯运行
    private void runWithoutLogic() {
        System.out.println("电梯运行~~");
    }

    // 电梯停止
    private void stopWithoutLogic() {
        System.out.println("电梯停止~~");
    }

    /* 有逻辑的电梯执行方法 */
    @Override
    public void open() {
        // 电梯在什么状态下才能开启
        switch (this.state) {
        case OPENING_STATE: {// 现在电梯为开启状态，不能再开启
            break;
        }
        case CLOSING_STATE: {// 现在电梯为关闭状态，可以开启,记得改变状态
            this.openWithoutLogic();
            this.setState(OPENING_STATE);
            break;
        }
        case RUNNING_STATE: {// 现在电梯为运行状态，这个时候不允许开门
            break;
        }
        case STOPPING_STATE: {// 现在电梯为停止状态，门本来就是关闭的，当然可以开启
            this.openWithoutLogic();
            this.setState(OPENING_STATE);
            break;
        }

        }
    }

    @Override
    public void close() {
        // 电梯在什么状态下才能关闭
        switch (this.state) {
        case OPENING_STATE: {// 现在电梯为开启状态，可以关闭，别忘了修改电梯的状态
            this.closeWithoutLogic();
            this.setState(CLOSING_STATE);
            break;
        }
        case CLOSING_STATE: {// 现在电梯为关闭状态，不能再关闭了
            break;
        }
        case RUNNING_STATE: {// 现在电梯为运行状态，门本来就是关闭的，不需要在关闭了
            break;
        }
        case STOPPING_STATE: {// 现在电梯为停止状态，门本来就是关闭的，不需要在关闭了
            break;
        }

        }
    }

    @Override
    public void run() {
        // 电梯在什么状态下才能运行
        switch (this.state) {
        case OPENING_STATE: {// 现在电梯为开启状态，不可以运行
            break;
        }
        case CLOSING_STATE: {// 现在电梯为关闭状态，可以运行
            this.runWithoutLogic();
            this.setState(RUNNING_STATE);
            break;
        }
        case RUNNING_STATE: {// 现在电梯为运行状态，
            break;
        }
        case STOPPING_STATE: {// 现在电梯为停止状态，可以运行
            this.runWithoutLogic();
            this.setState(RUNNING_STATE);
            break;
        }

        }
    }

    @Override
    public void stop() {

        // 电梯在什么状态下才能停止
        switch (this.state) {
        case OPENING_STATE: {// 现在电梯为开启状态，不能直接停止
            break;
        }
        case CLOSING_STATE: {// 现在电梯为关闭状态，可以停止
            this.stopWithoutLogic();
            this.setState(STOPPING_STATE);
            break;
        }
        case RUNNING_STATE: {// 现在电梯为运行状态，不可以停止
            break;
        }
        case STOPPING_STATE: {// 现在电梯为停止状态，不需要再停止了
            break;
        }

        }

    }

}

      • Client

        package com.peng.zt;

/**
 * @author kungfu~peng
 * @data 2017年11月28日
 * @description
 */
public class Client {
    public static void main(String[] args) {
        ILift lift = new Lift();
        // 电梯门的初始状态应该是停止状态
        lift.setState(Lift.STOPPING_STATE);
        // 开启电梯
        lift.open();
        // 然后关闭电梯门
        lift.close();
        // 电梯运行起来
        lift.run();
        // 到达目的地，停止电梯
        lift.stop();

    }
}

      • 执行结果

        电梯开启~~
电梯关闭~~
电梯运行~~
  • 程序有了，咱们再来挑挑骨头吧！
    1. 电梯的实现类【Lift】有点长
    2. 扩展性非常差--比如再加几个状态或者方法，变动很大。。。
    3. 非常规状态无法实现：电梯故障

  • 这些问题是实实在在存在的，现在我们换个角度看问题--这个状态是由什么动作产生的，以及这个状态下可以执行哪些动作【可以添加状态接口】

    • 类图
    • 解释： LiftState：在这之中，声明了一个受保护的类型Context变量，这个是串联各个状态的封装类，封装的目的很明显，就是电梯对象内部状态的变化不被调用类知晓，也就是迪米特法则，并且还定义了四个具体的实现类，承担的是状态产生以及状态间的转换过渡。

    • 代码

      • LiftState

        package zt2;

/**
 * @author kungfu~peng
 * @data 2017年11月29日
 * @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();

}

      • OpenningState

        package zt2;

/**
 * @author kungfu~peng
 * @data 2017年11月29日
 * @description 敞门状态
 */
public class OpenningState extends LiftState {

    @Override
    public void open() {
        System.out.println("电梯门已经开启~~");
    }

    @Override
    public void close() {
        // 状态修改
        super.context.setLiftState(Context.closingState);
        // 执行动作
        super.context.getLiftState().close();
    }

    @Override
    public void run() {
        // 不可执行
    }

    @Override
    public void stop() {
        // 不可执行
    }

}

      • ClosingState

        package zt2;

/**
 * @author kungfu~peng
 * @data 2017年11月29日
 * @description
 */
public class ClosingState extends LiftState {

    @Override
    public void open() {
        // 改变状态
        super.context.setLiftState(Context.openningState);
        // 执行
        super.context.getLiftState().open();
    }

    @Override
    public void close() {
        System.out.println("已经关闭~~");
    }

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

}

      • RunningState

        package zt2;

/**
 * @author kungfu~peng
 * @data 2017年11月29日
 * @description
 */
public class RunningState extends LiftState {

    @Override
    public void open() {
        System.out.println("不可操作~~");
    }

    @Override
    public void close() {
        System.out.println("正在运行，已经关闭~~");
    }

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

    @Override
    public void stop() {
        System.out.println("正在运行，无法停止~~");
        // 运行三秒钟，然后结束
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 设置状态
        super.context.setLiftState(Context.stoppingState);
        // 执行
        super.context.getLiftState().stop();
    }

}

      • StoppingState

        package zt2;

/**
 * @author kungfu~peng
 * @data 2017年11月29日
 * @description
 */
public class StoppingState extends LiftState {

    @Override
    public void open() {
        // 改变状态
        super.context.setLiftState(Context.openningState);
        // 执行
        super.context.getLiftState().open();
    }

    @Override
    public void close() {
        System.out.println("已经关闭~~");
    }

    @Override
    public void run() {
        // 设置状态
        super.context.setLiftState(Context.runningState);
        // 执行
        super.context.getLiftState().run();
    }

    @Override
    public void stop() {
        System.out.println("已经停止~~");
    }

}

      • Context

        package zt2;

/**
 * @author kungfu~peng
 * @data 2017年11月29日
 * @description
 */
public class Context {
    // 定义出所有的电梯状态
    public final static OpenningState openningState = new OpenningState();
    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 run() {
        this.liftState.run();
    }

    // 电梯停止
    public void stop() {
        this.liftState.stop();
    }

}

      • Client

        package zt2;

/**
 * @author kungfu~peng
 * @data 2017年11月29日
 * @description
 */
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();
    }

}

      • 执行结果

        电梯门已经开启~~
已经关闭~~
正在运行~~
正在运行，无法停止~~
已经停止~~ //注：上一个操作完之后的三秒之后执行此操作
  • 看看我们这段代码解决了哪些问题
    1. 代码太长--通过子类解决，子类的代码都比较短，也取消了switch-case的结构
    2. 不符合开闭原则--增加状态，现在只需在原有的类上增加即可，不用去修改
    3. 不符合迪米特法则--现在是各个状态的单独类，只有与这个状态相关的因素改了，这个类才做相应的修改

状态模式的定义

  • Allow an object to alter its behavior when its internal state changes.The object will appear to change its class.(当一个对象内在状态改变时允许其改变行为，这个对象看起来像改变了其类)
  • 状态模式的核心是封装，状态的变更引起了行为的变更，从外部看起来就像这个对象对应的类发生了改变一样

状态模式的通用类图

  • State:抽象状态角色--接口或抽象类，负责对象状态定义，并且封装环境角色以实现状态转换
  • ConcreteState：具体状态角色--每一个具体状态必须完成两个职责，本状态的行为管理以及趋向状态处理，通俗的说，就是本状态下要做的事情，以及 本状态如何过渡到其他状态
  • Context：定义客户端需要的接口，并且负责具体状态的切换

通用代码

  • 状态模式相对来说比较复杂，它提供了一种对物质运动的另一个观察视角，通过状态变更促使行为的变化，就类似水的状态变更一样，一碗水的初始状态是液态，通过加热转变为气态，状态的改变同时引起了体积的扩大，然后就产生了一个新的行为：鸣笛或顶起壶盖，瓦特就是这么发明的蒸汽机的

  • State

    package zt3;

/**
 * @author kungfu~peng
 * @data 2017年11月29日
 * @description
 */
public abstract class State {
    // 定义一个环境角色，提供子类访问
    protected Context context;

    // 设置环境角色

    public void setContext(Context context) {
        this.context = context;
    }

    // 行为1
    public abstract void handle1();

    // 行为2
    public abstract void handle2();

}

  • ConcreteState1

    package zt3;

/**
 * @author kungfu~peng
 * @data 2017年11月29日
 * @description
 */
public class ConcreteState1 extends State {
    @Override
    public void handle1() {
        // 本状态下必须处理的逻辑
        System.out.println("handle1~~~");
    }

    @Override
    public void handle2() {
        // 设置当前的状态为state2
        super.context.setCurrentState(Context.STATE2);
        //过渡到state2状态，由Context实现
        super.context.handle2();
    }

}

  • ConcreteState2

    package zt3;

/**
 * @author kungfu~peng
 * @data 2017年11月29日
 * @description
 */
public class ConcreteState2 extends State {

    @Override
    public void handle1() {
        // 设置当前的状态为state1
        super.context.setCurrentState(Context.STATE1);
        // 过渡到state1状态，由Context实现
        super.context.handle1();
    }

    @Override
    public void handle2() {
        // 本状态下必须处理的逻辑
        System.out.println("handle2~~~~");
    }

}

  • Context

    package zt3;

/**
 * @author kungfu~peng
 * @data 2017年11月29日
 * @description
 */
public class Context {
    // 定义状态
    public final static State STATE1 = new ConcreteState1();
    public final static State STATE2 = new ConcreteState2();
    // 当前状态
    private State CurrentState;

    // 获取当前状态
    public State getCurrentState() {
        return CurrentState;
    }

    // 设置当前状态
    public void setCurrentState(State currentState) {
        CurrentState = currentState;
        this.CurrentState.setContext(this);
    }

    // 行为委托
    public void handle1() {
        // 切换状态
        this.CurrentState.handle1();
    }

    public void handle2() {
        // 切换状态
        this.CurrentState.handle2();
    }

}

  • Client

    package zt3;

/**
 * @author kungfu~peng
 * @data 2017年11月29日
 * @description
 */
public class Client {

    public static void main(String[] args) {
        // 定义环境角色
        Context context = new Context();
        // 初始化状态
        context.setCurrentState(new ConcreteState1());
        // 行为执行
        context.handle1();
        context.handle2();
    }

}

  • 执行结果

    handle1~~~
handle2~~~~

不成文的规定

  • 把状态对象声明成静态常量，有几个状态对象就声明几个静态常量
  • 环境角色具有状态抽象角色定义的所有行为，具体执行使用委托方式

状态模式的应用

  • 状态模式的优点
    1. 结构清晰--避免了过多的switch-case或者if-else if的使用，避免了程序的复杂性，提高了系统的可维护性
    2. 遵循设计原则--开闭原则、单一职责原则
    3. 封装性非常好
  • 状态模式的缺点
    • 子类会太多【主要的缺点--数据库状态表可以来解决】
  • 使用场景
    1. 行为随着改变状态而改变的场景【权限设计】
    2. 条件、分支判断语句的替代者【switch-case、if-else if】
  • 注意事项
    • 状态模式适用于当某个对象在它的状态发生改变时，它的行为也随着发生比较大的变化，也就是说在行为受约束的情况下可以使用状态模式，而且使用对象的状态最好不超5个

最佳实践

  • 简单状态切换示意图【TCP监听：等待状态、连接状态、断开状态】
  • 复杂状态切换示意图牌【收费网站：普通用户、普通会员、VIP会员、白金用户】
  • 当电梯碰上维修
    • 改变电梯的执行顺序【建造模式+状态模式】
  • 状态机管理【State Machine】
    1. 初始化状态
    2. 挂起状态
    3. 完成状态

声明

  • 摘自秦小波《设计模式之禅》第2版；
  • 仅供学习，严禁商业用途；
  • 代码手写，没有经编译器编译，有个别错误，自行根据上下文改正；
乘风御浪云帆之上
关注
专栏目录
设计模式C++实现（16）——状态模式
wuzhekai的专栏
08-10 2万+
软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。设计模式中运用了面向对象编程语言的重要特性：封装、继承、多态，真正领悟设计模式的精髓是可能一个漫长的过程，需要大量实践经验的积累。最近看设计模式的书，对于每个模式，用C++写了个小例子，加深一下理解。主要参考《大
Java设计模式之禅
04-07
《Java设计模式之禅》是一本深入浅出讲解设计模式的书籍，书中不仅包含23种经典设计模式的案例，还详细介绍了设计模式背后的思想和原则，适合初学者以及对设计模式有一定了解的程序员阅读。本书旨在帮助读者理解如何...
设计模式——状态模式（State Pattern）
hunter800421的专栏
03-01 401
概念 在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。 在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。 要素 意图：允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类。 主要解决：对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关
【设计模式】——状态模式（State Pattern）
J^T的博客
08-06 594
状态模式（State Pattern）是一种重要的行为型设计模式，它允许一个对象在其内部状态改变时改变其行为，使得对象看起来像是改变了它的类。状态模式通过将状态相关的行为封装在独立的状态类中，有效地简化了条件逻辑，提高了代码的可维护性和可扩展性。
设计模式之禅之设计模式-状态模式
weixin_34235371的博客
01-28 136
一：状态模式定义 --->当一个对象内在状态改变时允许其改变行为,这个对象看起来像改变了其类 --->状态模式的核心是封装,状态的变更引起了行为的变更,从外部看起来就好像这个对象对应的类发生了改变一样 --->状态模式相对来说比较复杂,它提供了一种对物质运动的另一个观察视角,通过状态变更促使行为...
《设计模式之禅》-状态模式
Minstrel的博客
07-27 211
状态模式 定义： 当一个对象内在状态改变时允许其改变行为，这个对象看起来像改变了其类 状态模式的核心是封装，状态的变更引起了行为的变更，从外部看起来就好像这个对象对应的类发生了改变一样 通用类图 state 抽象状态角色 接口或抽象类，负责对象定义，并且封装环境角色以实现状态切换 ConcreteState 具体状态角色 每一个具体状态必须完成两个职责：本状态的行为...
设计模式之禅笔记——状态模式
很正经的程序员
07-16 702
一、状态模式的定义 Allow an object to alter its behavior when its internal state changes. The object will appear to change its class.(当一个对象的状态改变时允许其改变行为，这个对象看起来像改变了其类) 状态模式的核心是封装，状态的变更引起了行为的变更，从外部看来就好像这个对象对i...
【Java设计模式】《设计模式之禅》中的23种设计模式.zip
最新发布
09-11
【Java设计模式】《设计模式之禅》中的23种设计模式.zip 【Java设计模式】《设计模式之禅》中的23种设计模式.zip 【Java设计模式】《设计模式之禅》中的23种设计模式.zip 【Java设计模式】《设计模式之禅》中的23种...
设计者模式之禅第二版
03-28
《设计模式之禅（第2版）》是秦小波先生深入浅出地阐述软件设计模式的力作，尤其在第二版中，作者对原有的内容进行了更新和优化，旨在帮助读者更好地理解和应用设计模式，提升软件开发的效率和质量。设计模式是软件...
Java-Zen-of-Design.rar_zen_设计模式之禅
09-20
《Java设计之禅》是关于Java软件设计的一部著作，主要探讨了在开发过程中如何运用设计模式提升代码质量、可维护性和可扩展性。设计模式是面向对象编程中的一种最佳实践，是解决常见问题的经验总结，它使得开发者能够...
状态模式
03-01
博文链接：https://gznofeng.iteye.com/blog/235511
设计模式之禅——状态模式
aoe41606的博客
03-15 118
我们每一个人都乘过电梯。电梯的动作：开门、关门、执行、停止。 如今我们用程序来实现一个电梯的动作，先看类图设计，如图所看到的 如今看一下代码 public interface ILift { //开启电梯 public void open(); /...
设计模式之禅-状态模式
gclhaha的博客
04-06 206
状态模式 例子 电梯 电梯有四种状态，开门、关门、运行、停止。看似实现很简单，但是电梯的这4个动作的执行都有前置条件，具体点说就是在特定状态下才能做特定事。电梯的四种特定状态 敞门状态 按了电梯上下按钮，电梯门开，这中间大概有10秒的时间，那就是敞门状态。在这个状态下电梯只能做的动作是关门动作。 闭门状态 电梯门关闭了，在这个状态下，可以进行的动作是：开门（我不想坐电梯了）、停止（忘记按路层号了）、运行。 ...
读设计模式之禅--状态模式
he_yanghui的博客
08-30 124
定义：当一个对象内在状态改变时允许其改变行为，这个对象看起来像改变了其类。状态模式的核心是封装，状态的变更引起了行为的变更，从外部看起来就好像这个对象对应的类发生了改变一样 环境角色有两个不成文的约束： 把状态对象声明为静态常量，有几个状态对象就声明几个静态常量。 环境角色具有状态抽象角色定义的所有行为，具体执行使用委托方式。 package state; /** * @author hyh * @create 2021-08-28 11:05 * 抽象一个电梯 */ public.
《设计模式之禅》读书笔记--(21)状态模式
SigalHu
03-12 173
定义 当一个对象内在状态改变时允许其改变行为，这个对象看起来像改变了其类。 类图 State 抽象状态角色 接口或抽象类，负责对象状态定义，并且封装环境角色以实现状态切换。 ConcreteState 具体状态角色 每一个具体状态必须完成两个职责：本状态的行为管理以及趋向状态处理，通俗地说，就是本状态下要做的事情，以及本状态如何过渡到其他状态。 Context 环境角色 定...
设计模式之状态模式
qq_36029999的博客
11-04 282
调用：public class GameLoop : MonoBehaviour { private SceneStateController controller = null; void Awake() { DontDestroyOnLoad(this.gameObject); } void Start() {
23种设计模式-行为型模式-状态模式
诚
04-03 558
1. 简介   在软件开发过程中，应用程序中的有些对象可能会根据不同的情况做出不同的行为，我们把这种对象称为有状态的对象，而把影响对象行为的一个或多个动态变化的属性称为状态。当有状态的对象与外部事件产生互动时，其内部状态会发生改变，从而使得其行为也随之发生改变。如人的情绪有高兴的时候和伤心的时候，不同的情绪有不同的行为，当然外界也会影响其情绪变化。   对这种有状态的对象编程，传统的解决方案是：将...
设计模式之禅：JAVA实现与应用解析
本书《设计模式之禅 JAVA》以轻松的叙述方式，讲述了26种经典设计模式在Java编程中的应用，旨在帮助不同层次的开发者提升代码设计水平。书中不仅涵盖了初级到高级的各种设计模式，还穿插了Java的特定技术细节，旨在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

乘风御浪云帆之上

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值