行为型设计模式(五)状态模式【超级玛丽要变身】

最新推荐文章于 2021-09-10 10:52:29 发布
最新推荐文章于 2021-09-10 10:52:29 发布
阅读量416 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bo_book/article/details/109445878
版权

状态模式一般用来实现状态机，而状态机常用在游戏、工作流引擎等系统开发中。不过，状态机的实现方式有多种，除了状态模式，比较常用的还有分支逻辑法和查表法。今天，详细讲讲这几种实现方式，并且对比一下它们的优劣和应用场景。

目录

一、状态机

有限状态机，英文翻译是 Finite State Machine，缩写为 FSM，简称为状态机。状态机有 3 个组成部分：状态（State）、事件（Event）、动作（Action）。其中，事件也称为转移条件（Transition Condition）。事件触发状态的转移及动作的执行。不过，动作不是必须的，也可能只转移状态，不执行任何动作。

超级马里奥游戏中，马里奥可以变身为多种形态，比如小马里奥（Small Mario）、超级马里奥（Super Mario）、火焰马里奥（Fire Mario）、斗篷马里奥（Cape Mario）等等。在不同的游戏情节下，各个形态会互相转化，并相应的增减积分。比如，初始形态是小马里奥，吃了蘑菇之后就会变成超级马里奥，并且增加 100 积分。

实际上，马里奥形态的转变就是一个状态机。其中，马里奥的不同形态就是状态机中的“状态”，游戏情节（比如吃了蘑菇）就是状态机中的“事件”，加减积分就是状态机中的“动作”。比如，吃蘑菇这个事件，会触发状态的转移：从小马里奥转移到超级马里奥，以及触发动作的执行（增加 100 积分）。

如何将上面的状态转移图翻译成代码呢？
先给出整体实现功能的一个框架代码


public enum State {
  SMALL(0),
  SUPER(1),
  FIRE(2),
  CAPE(3);

  private int value;

  private State(int value) {
    this.value = value;
  }

  public int getValue() {
    return this.value;
  }
}

public class MarioStateMachine {
  private int score;
  private State currentState;

  public MarioStateMachine() {
    this.score = 0;
    this.currentState = State.SMALL;
  }

  public void obtainMushRoom() {
    //TODO
  }

  public void obtainCape() {
    //TODO
  }

  public void obtainFireFlower() {
    //TODO
  }

  public void meetMonster() {
    //TODO
  }

  public int getScore() {
    return this.score;
  }

  public State getCurrentState() {
    return this.currentState;
  }
}

public class ApplicationDemo {
  public static void main(String[] args) {
    MarioStateMachine mario = new MarioStateMachine();
    mario.obtainMushRoom();
    int score = mario.getScore();
    State state = mario.getCurrentState();
    System.out.println("mario score: " + score + "; state: " + state);
  }
}

二、解决状态机的几种思路

2.1 分支逻辑法

参照状态转移图，将每一个状态转移，原模原样地直译成代码。这样编写的代码会包含大量的 if-else 或 switch-case 分支判断逻辑，甚至是嵌套的分支判断逻辑，所以，我把这种方法暂且命名为分支逻辑法。
补全代码如下所示


public class MarioStateMachine {
  private int score;
  private State currentState;

  public MarioStateMachine() {
    this.score = 0;
    this.currentState = State.SMALL;
  }

  public void obtainMushRoom() {
    if (currentState.equals(State.SMALL)) {
      this.currentState = State.SUPER;
      this.score += 100;
    }
  }

  public void obtainCape() {
    if (currentState.equals(State.SMALL) || currentState.equals(State.SUPER) ) {
      this.currentState = State.CAPE;
      this.score += 200;
    }
  }

  public void obtainFireFlower() {
    if (currentState.equals(State.SMALL) || currentState.equals(State.SUPER) ) {
      this.currentState = State.FIRE;
      this.score += 300;
    }
  }

  public void meetMonster() {
    if (currentState.equals(State.SUPER)) {
      this.currentState = State.SMALL;
      this.score -= 100;
      return;
    }

    if (currentState.equals(State.CAPE)) {
      this.currentState = State.SMALL;
      this.score -= 200;
      return;
    }

    if (currentState.equals(State.FIRE)) {
      this.currentState = State.SMALL;
      this.score -= 300;
      return;
    }
  }

  public int getScore() {
    return this.score;
  }

  public State getCurrentState() {
    return this.currentState;
  }
}

简单的状态机来说，分支逻辑这种实现方式是可以接受的。但是，对于复杂的状态机来说，这种实现方式极易漏写或者错写某个状态转移。除此之外，代码中充斥着大量的 if-else 或者 switch-case 分支判断逻辑，可读性和可维护性都很差。如果哪天修改了状态机中的某个状态转移，我们要在冗长的分支逻辑中找到对应的代码进行修改，很容易改错，引入 bug。

2.2 查表法

上面这种实现方法有点类似 hard code，对于复杂的状态机来说不适用，而状态机的第二种实现方式查表法，就更加合适了。接下来，我们就一块儿来看下，如何利用查表法来补全骨架代码。

实际上，除了用状态转移图来表示之外，状态机还可以用二维表来表示，如下所示。在这个二维表中，第一维表示当前状态，第二维表示事件，值表示当前状态经过事件之后，转移到的新状态及其执行的动作。

相对于分支逻辑的实现方式，查表法的代码实现更加清晰，可读性和可维护性更好。当修改状态机时，我们只需要修改 transitionTable 和 actionTable 两个二维数组即可。实际上，如果我们把这两个二维数组存储在配置文件中，当需要修改状态机时，我们甚至可以不修改任何代码，只需要修改配置文件就可以了。具体的代码如下所示：


public enum Event {
  GOT_MUSHROOM(0),
  GOT_CAPE(1),
  GOT_FIRE(2),
  MET_MONSTER(3);

  private int value;

  private Event(int value) {
    this.value = value;
  }

  public int getValue() {
    return this.value;
  }
}

public class MarioStateMachine {
  private int score;
  private State currentState;

  private static final State[][] transitionTable = {
          {SUPER, CAPE, FIRE, SMALL},
          {SUPER, CAPE, FIRE, SMALL},
          {CAPE, CAPE, CAPE, SMALL},
          {FIRE, FIRE, FIRE, SMALL}
  };

  private static final int[][] actionTable = {
          {+100, +200, +300, +0},
          {+0, +200, +300, -100},
          {+0, +0, +0, -200},
          {+0, +0, +0, -300}
  };

  public MarioStateMachine() {
    this.score = 0;
    this.currentState = State.SMALL;
  }

  public void obtainMushRoom() {
    executeEvent(Event.GOT_MUSHROOM);
  }

  public void obtainCape() {
    executeEvent(Event.GOT_CAPE);
  }

  public void obtainFireFlower() {
    executeEvent(Event.GOT_FIRE);
  }

  public void meetMonster() {
    executeEvent(Event.MET_MONSTER);
  }

  private void executeEvent(Event event) {
    int stateValue = currentState.getValue();
    int eventValue = event.getValue();
    this.currentState = transitionTable[stateValue][eventValue];
    this.score += actionTable[stateValue][eventValue];
  }

  public int getScore() {
    return this.score;
  }

  public State getCurrentState() {
    return this.currentState;
  }

}

2.3 状态模式法

查表法的代码实现中，事件触发的动作只是简单的积分加减，所以，我们用一个 int 类型的二维数组 actionTable 就能表示，二维数组中的值表示积分的加减值。但是，如果要执行的动作并非这么简单，而是一系列复杂的逻辑操作（比如加减积分、写数据库，还有可能发送消息通知等等），我们就没法用如此简单的二维数组来表示了。这也就是说，查表法的实现方式有一定局限性。

状态模式通过将事件触发的状态转移和动作执行，拆分到不同的状态类中，来避免分支判断逻辑。


public interface IMario { //所有状态类的接口
  State getName();
  //以下是定义的事件
  void obtainMushRoom();
  void obtainCape();
  void obtainFireFlower();
  void meetMonster();
}

public class SmallMario implements IMario {
  private MarioStateMachine stateMachine;

  public SmallMario(MarioStateMachine stateMachine) {
    this.stateMachine = stateMachine;
  }

  @Override
  public State getName() {
    return State.SMALL;
  }

  @Override
  public void obtainMushRoom() {
    stateMachine.setCurrentState(new SuperMario(stateMachine));
    stateMachine.setScore(stateMachine.getScore() + 100);
  }

  @Override
  public void obtainCape() {
    stateMachine.setCurrentState(new CapeMario(stateMachine));
    stateMachine.setScore(stateMachine.getScore() + 200);
  }

  @Override
  public void obtainFireFlower() {
    stateMachine.setCurrentState(new FireMario(stateMachine));
    stateMachine.setScore(stateMachine.getScore() + 300);
  }

  @Override
  public void meetMonster() {
    // do nothing...
  }
}

public class SuperMario implements IMario {
  private MarioStateMachine stateMachine;

  public SuperMario(MarioStateMachine stateMachine) {
    this.stateMachine = stateMachine;
  }

  @Override
  public State getName() {
    return State.SUPER;
  }

  @Override
  public void obtainMushRoom() {
    // do nothing...
  }

  @Override
  public void obtainCape() {
    stateMachine.setCurrentState(new CapeMario(stateMachine));
    stateMachine.setScore(stateMachine.getScore() + 200);
  }

  @Override
  public void obtainFireFlower() {
    stateMachine.setCurrentState(new FireMario(stateMachine));
    stateMachine.setScore(stateMachine.getScore() + 300);
  }

  @Override
  public void meetMonster() {
    stateMachine.setCurrentState(new SmallMario(stateMachine));
    stateMachine.setScore(stateMachine.getScore() - 100);
  }
}

// 省略CapeMario、FireMario类...

public class MarioStateMachine {
  private int score;
  private IMario currentState; // 不再使用枚举来表示状态

  public MarioStateMachine() {
    this.score = 0;
    this.currentState = new SmallMario(this);
  }

  public void obtainMushRoom() {
    this.currentState.obtainMushRoom();
  }

  public void obtainCape() {
    this.currentState.obtainCape();
  }

  public void obtainFireFlower() {
    this.currentState.obtainFireFlower();
  }

  public void meetMonster() {
    this.currentState.meetMonster();
  }

  public int getScore() {
    return this.score;
  }

  public State getCurrentState() {
    return this.currentState.getName();
  }

  public void setScore(int score) {
    this.score = score;
  }

  public void setCurrentState(IMario currentState) {
    this.currentState = currentState;
  }
}

Mario 是状态的接口，定义了所有的事件。SmallMario、SuperMario、CapeMario、FireMario 是 IMario 接口的实现类，分别对应状态机中的 4 个状态。原来所有的状态转移和动作执行的代码逻辑，都集中在 MarioStateMachine 类中，现在，这些代码逻辑被分散到了这 4 个状态类中。

上面的代码还可以继续优化，我们可以将状态类设计成单例，毕竟状态类中不包含任何成员变量。

public interface IMario {
  State getName();
  void obtainMushRoom(MarioStateMachine stateMachine);
  void obtainCape(MarioStateMachine stateMachine);
  void obtainFireFlower(MarioStateMachine stateMachine);
  void meetMonster(MarioStateMachine stateMachine);
}

public class SmallMario implements IMario {
  private static final SmallMario instance = new SmallMario();
  private SmallMario() {}
  public static SmallMario getInstance() {
    return instance;
  }

  @Override
  public State getName() {
    return State.SMALL;
  }

  @Override
  public void obtainMushRoom(MarioStateMachine stateMachine) {
    stateMachine.setCurrentState(SuperMario.getInstance());
    stateMachine.setScore(stateMachine.getScore() + 100);
  }

  @Override
  public void obtainCape(MarioStateMachine stateMachine) {
    stateMachine.setCurrentState(CapeMario.getInstance());
    stateMachine.setScore(stateMachine.getScore() + 200);
  }

  @Override
  public void obtainFireFlower(MarioStateMachine stateMachine) {
    stateMachine.setCurrentState(FireMario.getInstance());
    stateMachine.setScore(stateMachine.getScore() + 300);
  }

  @Override
  public void meetMonster(MarioStateMachine stateMachine) {
    // do nothing...
  }
}

// 省略SuperMario、CapeMario、FireMario类...

public class MarioStateMachine {
  private int score;
  private IMario currentState;

  public MarioStateMachine() {
    this.score = 0;
    this.currentState = SmallMario.getInstance();
  }

  public void obtainMushRoom() {
    this.currentState.obtainMushRoom(this);
  }

  public void obtainCape() {
    this.currentState.obtainCape(this);
  }

  public void obtainFireFlower() {
    this.currentState.obtainFireFlower(this);
  }

  public void meetMonster() {
    this.currentState.meetMonster(this);
  }

  public int getScore() {
    return this.score;
  }

  public State getCurrentState() {
    return this.currentState.getName();
  }

  public void setScore(int score) {
    this.score = score;
  }

  public void setCurrentState(IMario currentState) {
    this.currentState = currentState;
  }
}

像游戏这种比较复杂的状态机，包含的状态比较多，我优先推荐使用查表法，而状态模式会引入非常多的状态类，会导致代码比较难维护。相反，像电商下单、外卖下单这种类型的状态机，它们的状态并不多，状态转移也比较简单，但事件触发执行的动作包含的业务逻辑可能会比较复杂，所以，更加推荐使用状态模式来实现。

三、状态模式总结

第一种实现方式叫分支逻辑法。利用 if-else 或者 switch-case 分支逻辑，参照状态转移图，将每一个状态转移原模原样地直译成代码。对于简单的状态机来说，这种实现方式最简单、最直接，是首选。

第二种实现方式叫查表法。对于状态很多、状态转移比较复杂的状态机来说，查表法比较合适。通过二维数组来表示状态转移图，能极大地提高代码的可读性和可维护性。

第三种实现方式叫状态模式。对于状态并不多、状态转移也比较简单，但事件触发执行的动作包含的业务逻辑可能比较复杂的状态机来说，我们首选这种实现方式。

HDGM3
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
设计模式学习笔记（三）
荆赤潮的博客
09-21 130
9. 迭代器模式 迭代器模式提供一种方法顺序访问一个聚合对象的各个元素，而又不暴露其内部的细节。 这使得接口变得更加简洁，也可以让聚合对象更专注在管理对象集合上面，而不必去理会遍历的事情。 大概实现 Emmmm……为多个类都提供一个迭代器子类。 例子（《head first 设计模式》） 用简单数组写的菜单和用vector写得菜单的组合。 例子（《JavaScript 设计模式》） ...
超级玛丽-游戏里的设计模式
qq_19864679的博客
09-19 534
策略模式策略模式模式定义超级玛丽：策略模式实现技能切换 策略模式 分析项目变化与不变部分，提取变化部分，抽象成接口+实现；(抽象是共性，接口是特性)。 模式定义 策略模式定义了算法簇，分别封装起来，让它们之间可以互相替换，此模式的变化独立于算法的使用者： c++里的sort排序函数，就是一个典型的策略模式，它排序的时候，需要我们传给它一个排序规则。 超级玛丽： 再比如超级玛丽这个游戏，在这里，小管道工就是一个封装类： 管道工拥有的行为： 1. 人物的描述 2. 移动 3. 攻击 因为游戏里面，这
超级马里奥项目设计（二）
PLX_Pan的博客
07-20 964
《超级马里奥》游戏中马里奥和怪物都有相应的动作，这些动作是如何实现的呢？后面几篇文章我们会详细去讲解设计思路。今天我们先讲解一下马里奥动作的实现。 大家可以回忆一下以前我们玩的超级马里奥游戏中，马里奥都有哪些动作？跑、跳、吃金币、踩乌龟、踩蘑菇怪等。今天我们通过scartch模块化编程带领大家去了解一下如何去实现这些动作。 以上设计是实现马里奥的跑的功能。当按下键盘上的右方向键时候，马里奥就会按照设计沿着x轴位移对应像素的长度，并且在位移过程中每移动两个像素的长度等待0.001秒后切换到下一个马里奥的图片
《魂斗罗归来》之代理模式VS装饰模式
weixin_34352449的博客
11-21 96
欢迎收看俗到掉渣的《小Y讲堂》节目，大家好，我是小Y,一个集性感毛发与才华于一身的程序猿。小Y的设计模式系列中的**「代理模式」和「装饰模式」**在前面已经总结过了，又是时候唠叨唠叨这两者之间在《魂斗罗归来》中的是是非非了。 一、模式介绍 1.通用UML的对比 从上图可以看到，代理模式和装饰模式的类图非常类似，装饰模式可以说是代理模式的一个特殊应用，两者的共同点是都具有相同的接口。 2.模式的介...
马里奥游戏开发项目(Java)
hxxjxw的博客
03-27 2714
一、程序分析： a）使用Java的面向对象设计思路来完成游戏程序，和类的设计 i.Mario对象 ii.敌人对象 iii.障碍物对象 iv.场景对象 v.窗体对象 vi.图片及背景音乐，在该类中，所有的属性都应该是静态（static）的属性 b）总代码量：100-2000行 二...
毕业设计 - 基于Java的超级玛丽游戏的设计与实现
最新发布
06-07
超级玛丽小游戏的JAVA程序，进入游戏后首先按空格键开始， 利用方向键来控制的马里奥的移动，同时检测马里奥与场景中 的障碍物和敌人的碰撞，并判断马里奥的可移动性和马里奥的 生命值。当马里奥通过最后一个场景后...
基于Java的超级玛丽游戏的设计与实现.zip
12-30
基于Java的超级玛丽游戏的设计与实现上传的项目源码配置好环境和数据库均可以运行，为了方便大家对于java的学习，作为毕业设计的参考也是非常合适的，欢迎大家交流！
C语言游戏源码 超级玛丽游戏源码
06-23
C语言游戏源码 超级玛丽游戏源码C语言游戏源码 超级玛丽游戏源码C语言游戏源码 超级玛丽游戏源码C语言游戏源码 超级玛丽游戏源码C语言游戏源码 超级玛丽游戏源码C语言游戏源码 超级玛丽游戏源码C语言游戏源码 超级...
基于Java的超级玛丽游戏的设计与实现答辩ppt.ppt
06-20
基于Java的超级玛丽游戏的设计与实现答辩ppt
C语言超级玛丽游戏 C语言超级玛丽游戏
06-16
C语言超级玛丽游戏C语言超级玛丽游戏C语言超级玛丽游戏C语言超级玛丽游戏C语言超级玛丽游戏C语言超级玛丽游戏C语言超级玛丽游戏C语言超级玛丽游戏C语言超级玛丽游戏C语言超级玛丽游戏C语言超级玛丽游戏C语言超级玛丽...
unity超级马里奥Demo
06-14
该项目是unity制作的一款马里奥小游戏，原生素材；游戏的内容比较齐全
设计模式-状态模式
Eistert
09-10 143
介绍 状态机的实现 状态模式一般用来实现状态机，而状态机常用在游戏、工作流引擎等系统开发中。不过，状态机的实现方式有多种，除了状态模式，比较常用的还有分支逻辑法和查表法。 今天，我们就详细讲讲这几种实现方式，并且对比一下它们的优劣和应用场景。 什么是有限状态机 有限状态机，英文翻译是 Finite State Machine，缩写为 FSM，简称为状态机。状态机有 3 个组成部分：状态（State）、事件（Event）、动作（Action）。其中，事件也称为转移条件（Transition Condition
设计模式之美25--状态模式
sinat_36454672的博客
08-26 376
状态机的实现方式有多种，除了状态模式，比较常用的还有 分支逻辑法 和 查表法。 状态机又叫有限状态机，它有3个部分组成：状态、事件、动作。 超级玛丽示例: 1, 分之逻辑法 class MarioStateMachine { private int score; private State currentState; public MarioStateMachine() { this.score = 0; this.currentState = S
设计模式深入学习--State 状态模式(行为型模式)
LonelySu
01-16 508
这次来说说State状态模式，State状态模式用于我们在编程开发中大量用到 if Else的情况下，有很多分支的判断那么用状态模式就最好不过了，如在AI设计中的状态机就可以用State状态模式来设计一个AI机器人。 我们先来看看State状态模式的基本代码。 //抽象状态类 定义一个接口以封装与Context的一个特定状态相关的行为 abstract class State {
《JAVA与模式》之状态模式
weixin_30838921的博客
06-08 239
在阎宏博士的《JAVA与模式》一书中开头是这样描述状态（State）模式的： 　　状态模式，又称状态对象模式（Pattern of Objects for States），状态模式是对象的行为模式。 　　状态模式允许一个对象在其内部状态改变的时候改变其行为。这个对象看上去就像是改变了它的类一样。 状态模式的结构 　　用一句话来表述，状态模式把所研究的对象的行为包装在不同的状态对象里，每一个...
趣谈设计模式 | 状态模式(State)：如何实现游戏中的状态切换？
凌桓丶的博客
11-02 3336
文章目录案例：马里奥积分竞赛有限状态机分支逻辑法查表法状态模式孪生兄弟:状态模式与策略模式总结完整代码与文档 案例：马里奥积分竞赛 喜欢马里奥的小伙伴们都应该知道，前不久马里奥为了庆祝35周年，推出了一款以多人对抗大逃杀为核心的超级马里奥兄弟35 此处仅为举例，并无此开发计划 由于新颖的游戏模式带来了巨大的热度，于是任天堂决定趁热打铁，推出一款马里奥竞技游戏，在一定时间内获得积分最多的玩家将获得胜利。考虑到游戏并非正传，于是任天堂将游戏的开发工作外包给了小明所在的游戏公司来进行制作。 游戏的核心玩法就是
Python 超级玛丽代码实现(1):界面和状态机实现
热门推荐
marble_xu的博客
07-19 4万+
python 超级玛丽代码实现（1）：界面和状态机实现游戏介绍状态机介绍状态机代码实现 游戏介绍 小时候的经典游戏，代码参考了github上的项目，还是使用pygame来实现，从中学习到了横版过关游戏实现中的一些处理方法。原项目实现了超级玛丽的第一个小关。 在原项目的基础上，游戏使用json文件来保存每一个关卡的数据，将数据和代码解耦合，目前已开发4个小关，后续关卡的扩展也很方便，只需要添加jso...
lsdyna如何设置set中的node_list_如何用 Python 实现超级玛丽的界面和状态机？
weixin_39946239的博客
11-20 354
作者 | marble_xu责编 | 郭芮出品 | CSDN博客小时候的经典游戏，代码参考了github上的项目Mario-Level-1(https://github.com/justinmeister/Mario-Level-1)，使用pygame来实现，从中学习到了横版过关游戏实现中的一些处理方法。原项目实现了超级玛丽的第一个小关。在原项目的基础上，游戏使用json文件来保存每一个...
运单状态机设计及全流程异常跟踪整体架构
萝卜头柯克船长的博客
11-26 1106
文章目录1. 业务背景1. 需求1.2 难点2. 状态机简介2.1 定义2.2 举例3. 运单环节状态机实现4. 整体架构 1. 业务背景 1. 需求 业务方希望能够对运单的揽收、干支运输、派送等各个环节的操作规范进行监控，同时将温湿监控、设备监控、配置监控等孤立的报警项映射到运单环节之上。 运单环节由运单状态映射而得，譬如干支运输环节的典型状态区间是封车–>解封车。 1.2 难点 运单环节映射最大的难点在于，无论是在系统上还是运营上，运单的各个关键状态都不是严格齐全的、有序的，存在大量的漏操作、补操
超级玛丽java设计思路
11-26
超级玛丽java设计思路主要包括游戏引擎的搭建、角色和场景的设计以及用户交互的实现。首先，需要构建一个游戏引擎，包括游戏循环、渲染系统、物理引擎等核心功能，以保证游戏的稳定性和流畅性。其次，需要设计超级玛丽和其他游戏角色的行为和动画，包括移动、跳跃、攻击等动作，并且需要考虑它们与场景的交互，以及碰撞检测和响应。同时，还需要设计多个关卡的场景，包括地图、背景、障碍物等元素，并为不同的关卡设置不同的难度和目标，以增加游戏的趣味性和挑战性。最后，需要实现用户输入的处理，包括键盘和鼠标的事件响应，以及菜单、得分统计等界面的显示，使用户能够方便地与游戏进行交互。总的来说，超级玛丽java设计思路需要围绕游戏引擎搭建、角色和场景设计以及用户交互实现这三个方面展开，同时需要注重游戏性和用户体验，以打造一款经典的超级玛丽java版游戏。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值