20-状态模式

已于 2022-04-17 11:37:34 修改
阅读量81 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 状态模式
于 2022-01-29 22:48:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZSA222/article/details/122748546
版权

文章目录

APP 抽奖活动问题

请编写程序完成 APP 抽奖活动具体要求如下：

  • 1）假如每参加一次这个活动要扣除用户 50 积分，中奖概率是 10%
  • 2）奖品数量固定，抽完就不能抽奖
  • 3）活动有四个状态：可以抽奖、不能抽奖、发放奖品和奖品领完
  • 4）活动的四个状态转换关系图

在这里插入图片描述

状态模式基本介绍

  • 1）状态模式（State Pattern）：它主要用来解决对象在多种状态转换时，需要对外输出不同的行为的问题。状态和行为是一一对应的，状态之间可以相互转换
  • 2）当一个对象的内在状态改变时，允许改变其行为，这个对象看起来像是改变了其类

原理类图

在这里插入图片描述

角色与职责

  • Context环境角色：维护一个State实例，这个实例定义了当前状态
  • State抽象状态角色：定义一个接口，封装与Context的一个特点接口相关行为
  • ConcreteState具体状态角色：实现一个与Context的一个状态相关行为

状态模式解决 APP 抽奖问题

  • 1）应用实例要求完成 APP 抽奖活动项目，使用状态模式
  • 2）思路分析和图解（类图）
    • 定义出一个接口叫状态接口，每个状态都实现它
    • 接口有扣除积分方法、抽奖方法、发放奖品方法

UML 类图
在这里插入图片描述
核心代码

抽象状态角色

/**
 * 状态抽象类
 * @author Administrator
 *
 */
public abstract class State {

    // 扣除积分 - 50
    public abstract void deductMoney();

    // 是否抽中奖品
    public abstract boolean raffle();

    // 发放奖品
    public abstract  void dispensePrize();

}

不能抽奖状态类

/**
 * 不能抽奖状态
 * @author Administrator
 *
 */
public class NoRaffleState extends State {

    // 初始化时传入活动引用，扣除积分后改变其状态
    RaffleActivity activity;

    public NoRaffleState(RaffleActivity activity) {
        this.activity = activity;
    }

    // 当前状态可以扣积分 , 扣除后，将状态设置成可以抽奖状态
    @Override
    public void deductMoney() {
        System.out.println("扣除50积分成功，您可以抽奖了");
        activity.setState(activity.getCanRaffleState());
    }

    // 当前状态不能抽奖
    @Override
    public boolean raffle() {
        System.out.println("扣了积分才能抽奖喔！");
        return false;
    }

    // 当前状态不能发奖品
    @Override
    public void dispensePrize() {
        System.out.println("不能发放奖品");
    }
}

可以抽奖状态类

/**
 * 可以抽奖的状态
 * @author Administrator
 *
 */
public class CanRaffleState extends State {

    RaffleActivity activity;

    public CanRaffleState(RaffleActivity activity) {
        this.activity = activity;
    }

    // 已经扣除了积分，不能再扣
    @Override
    public void deductMoney() {
        System.out.println("已经扣取过了积分");
    }

    // 可以抽奖, 抽完奖后，根据实际情况，改成新的状态
    @Override
    public boolean raffle() {
        System.out.println("正在抽奖，请稍等！");
        Random r = new Random();
        int num = r.nextInt(10);
        // 10%中奖机会
        if(num == 0){
            // 改变活动状态为发放奖品 context
            activity.setState(activity.getDispenseState());
            return true;
        }else{
            System.out.println("很遗憾没有抽中奖品！");
            // 改变状态为不能抽奖
            activity.setState(activity.getNoRafflleState());
            return false;
        }
    }

    // 不能发放奖品
    @Override
    public void dispensePrize() {
        System.out.println("没中奖，不能发放奖品");
    }
}

发放奖品状态类

/**
 * 发放奖品的状态
 * @author Administrator
 *
 */
public class DispenseState extends State {

    // 初始化时传入活动引用，发放奖品后改变其状态
    RaffleActivity activity;

    public DispenseState(RaffleActivity activity) {
        this.activity = activity;
    }

    //

    @Override
    public void deductMoney() {
        System.out.println("不能扣除积分");
    }

    @Override
    public boolean raffle() {
        System.out.println("不能抽奖");
        return false;
    }

    //发放奖品
    @Override
    public void dispensePrize() {
        if(activity.getCount() > 0){
            System.out.println("恭喜中奖了");
            // 改变状态为不能抽奖
            activity.setState(activity.getNoRafflleState());
        }else{
            System.out.println("很遗憾，奖品发送完了");
            // 改变状态为奖品发送完毕, 后面我们就不可以抽奖
            activity.setState(activity.getDispensOutState());
            //System.out.println("抽奖活动结束");
            //System.exit(0);
        }

    }
}

奖品领完状态类

/**
 * 奖品发放完毕状态
 * 说明，当我们activity 改变成 DispenseOutState， 抽奖活动结束
 * @author Administrator
 *
 */
public class DispenseOutState extends State {

    // 初始化时传入活动引用
    RaffleActivity activity;

    public DispenseOutState(RaffleActivity activity) {
        this.activity = activity;
    }
    @Override
    public void deductMoney() {
        System.out.println("奖品发送完了，请下次再参加");
    }

    @Override
    public boolean raffle() {
        System.out.println("奖品发送完了，请下次再参加");
        return false;
    }

    @Override
    public void dispensePrize() {
        System.out.println("奖品发送完了，请下次再参加");
    }
}

抽奖活动

/**
 * 抽奖活动 //
 *
 * @author Administrator
 *
 */
public class RaffleActivity {

    // state 表示活动当前的状态，是变化
    State state = null;
    // 奖品数量
    int count = 0;

    // 四个属性，表示四种状态
    State noRafflleState = new NoRaffleState(this);
    State canRaffleState = new CanRaffleState(this);

    State dispenseState =   new DispenseState(this);
    State dispensOutState = new DispenseOutState(this);

    //构造器
    //1. 初始化当前的状态为 noRafflleState（即不能抽奖的状态）
    //2. 初始化奖品的数量
    public RaffleActivity( int count) {
        this.state = getNoRafflleState();
        this.count = count;
    }

    //扣分, 调用当前状态的 deductMoney
    public void debuctMoney(){
        state.deductMoney();
    }

    //抽奖
    public void raffle(){
        // 如果当前的状态是抽奖成功
        if(state.raffle()){
            //领取奖品
            state.dispensePrize();
        }

    }

    public State getState() {
        return state;
    }

    public void setState(State state) {
        this.state = state;
    }

    //这里请大家注意，每领取一次奖品，count--
    public int getCount() {
        int curCount = count;
        count--;
        return curCount;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public State getNoRafflleState() {
        return noRafflleState;
    }

    public void setNoRafflleState(State noRafflleState) {
        this.noRafflleState = noRafflleState;
    }

    public State getCanRaffleState() {
        return canRaffleState;
    }

    public void setCanRaffleState(State canRaffleState) {
        this.canRaffleState = canRaffleState;
    }

    public State getDispenseState() {
        return dispenseState;
    }

    public void setDispenseState(State dispenseState) {
        this.dispenseState = dispenseState;
    }

    public State getDispensOutState() {
        return dispensOutState;
    }

    public void setDispensOutState(State dispensOutState) {
        this.dispensOutState = dispensOutState;
    }
}

测试代码

/**
 * 状态模式测试类
 * @author Administrator
 *
 */
public class ClientTest {

    public static void main(String[] args) {
        // 创建活动对象，奖品有1个奖品
        RaffleActivity activity = new RaffleActivity(1);

        // 我们连续抽300次奖
        for (int i = 0; i < 30; i++) {
            System.out.println("--------第" + (i + 1) + "次抽奖----------");
            // 参加抽奖，第一步点击扣除积分
            activity.debuctMoney();

            // 第二步抽奖
            activity.raffle();
        }
    }

}

状态模式在实际项目——借贷平台源码剖析

  • 1）借贷平台的订单，有审核-发布-抢单等等步骤，随着操作的不同，会改变订单的状态，项目中的这个模块实现就会使用到状态模式
  • 2）通常通过if/else判断订单的状态，从而实现不同的逻辑，伪代码如下
    问题分析：这类代码难以应对变化，在添加一种状态时，我们需要手动添加if/else，在添加一种功能时，要对所有的状态进行判断。因此代码会变得越来越臃肿，并且一旦没有处理某个状态，便会发生极其严重的 BUG，难以维护
if(审核){
    //审核逻辑
}else if(发布){
    //发布逻辑
}else if(接单){
    //接单逻辑
}
  • 3）使用状态模式完成借贷平台项目的审核模块 [设计+代码]

设计

借贷平台—流程审批
状态模式本质上是一种基于状态和事件的状态机，下面是订单流程的状态图
在这里插入图片描述
通过状态图，我们再设计一张横纵坐标关系表来比较，如下图
在这里插入图片描述
UML 类图
在这里插入图片描述

代码

状态接口

/**
 * 状态接口
 */
public interface State {
    /**
     * 电审
     *
     * @param context
     */
    void electronicAudit(Context context);

    /**
     * 电审失败
     *
     * @param context
     */
    void electronicAuditFail(Context context);

    /**
     * 定价发布
     *
     * @param context
     */
    void releasePricing(Context context);

    /**
     * 接单
     *
     * @param context
     */
    void acceptOrder(Context context);

    /**
     * 接单失败
     *
     * @param context
     */
    void acceptOrderFail(Context context);

    /**
     * 付款
     *
     * @param context
     */
    void payMoney(Context context);

    /**
     * 反馈【下款 或 拒贷】
     *
     * @param context
     */
    void feedback(Context context);

    String getCurrentState();
}

抽象状态类

/**
 * 抽象状态类，默认实现
 */
public abstract class AbstractState implements State {
    private static final RuntimeException EXCEPTION = new RuntimeException("操作流程有误");

    @Override
    public void electronicAudit(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void electronicAuditFail(Context context) {
        throw EXCEPTION;

    }

    @Override
    public void releasePricing(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void acceptOrder(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void acceptOrderFail(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void payMoney(Context context) {
        throw EXCEPTION;
    }

    @Override
    public void feedback(Context context) {
        throw EXCEPTION;
    }
}

具体状态类

/**
 * 订单生成状态类
 */
public class GeneratedState extends AbstractState {
    @Override
    public void electronicAudit(Context context) {
        context.setState(new AuditedState());
    }

    @Override
    public void electronicAuditFail(Context context) {
        context.setState(new FinishedState());
    }

    @Override
    public String getCurrentState() {
        return StateEnum.GENERATED.name();
    }
}
/**
 * 已审核状态类
 */
public class AuditedState extends AbstractState {
    @Override
    public void releasePricing(Context context) {
        context.setState(new PublishedState());
    }

    @Override
    public String getCurrentState() {
        return StateEnum.AUDITED.name();
    }
}
/**
 * 已发布状态类
 */
public class PublishedState extends AbstractState {
    @Override
    public void acceptOrder(Context context) {
        context.setState(new NotPaidState());
    }

    @Override
    public void acceptOrderFail(Context context) {
        context.setState(new FinishedState());
    }

    @Override
    public String getCurrentState() {
        return StateEnum.PUBLISHED.name();
    }
}
/**
 * 未付款状态类
 */
public class NotPaidState extends AbstractState {
    @Override
    public void payMoney(Context context) {
        context.setState(new PaidState());
    }

    @Override
    public void feedback(Context context) {
        context.setState(new FinishedState());
    }

    @Override
    public String getCurrentState() {
        return StateEnum.NOT_PAID.name();
    }
}
/**
 * 未付款状态类
 */
public class PaidState extends AbstractState {
    @Override
    public void feedback(Context context) {
        context.setState(new FinishedState());
    }

    @Override
    public String getCurrentState() {
        return StateEnum.PAID.name();
    }
}
/**
 * 未付款状态类
 */
public class FinishedState extends AbstractState {
    @Override
    public String getCurrentState() {
        return StateEnum.FINISHED.name();
    }
}

状态枚举类

public enum StateEnum {
    GENERATED,
    AUDITED,
    PUBLISHED,
    NOT_PAID,
    PAID,
    FINISHED;
}

上下文环境类

/**
 * 上下文环境类
 */
public class Context extends AbstractState {
    private State state;

    public Context() {
        state = new GeneratedState();
    }

    @Override
    public void electronicAudit(Context context) {
        state.electronicAudit(context);
        getCurrentState();
    }

    @Override
    public void electronicAuditFail(Context context) {
        state.electronicAuditFail(context);
        getCurrentState();
    }

    @Override
    public void releasePricing(Context context) {
        state.releasePricing(context);
        getCurrentState();
    }

    @Override
    public void acceptOrder(Context context) {
        state.acceptOrder(context);
        getCurrentState();
    }

    @Override
    public void acceptOrderFail(Context context) {
        state.acceptOrderFail(context);
        getCurrentState();
    }

    @Override
    public void payMoney(Context context) {
        state.payMoney(context);
        getCurrentState();
    }

    @Override
    public void feedback(Context context) {
        state.feedback(context);
        getCurrentState();
    }

    public State getState() {
        return state;
    }

    public void setState(State state) {
        this.state = state;
    }

    @Override
    public String getCurrentState() {
        System.out.println("当前状态：" + state.getCurrentState());
        return state.getCurrentState();
    }
}

测试代码

Context context = new Context();
context.electronicAudit(context);
context.releasePricing(context);
context.acceptOrder(context);
context.payMoney(context);

context.electronicAuditFail(context);
context.acceptOrderFail(context);
//当前状态：AUDITED
//当前状态：PUBLISHED
//当前状态：NOT_PAID
//当前状态：PAID
//Exception in thread "main" java.lang.RuntimeException: 操作流程有误
//	at com.vectorx.pattern.t20_state.lendingplatform.AbstractState.<clinit>(AbstractState.java:7)
//	at com.vectorx.pattern.t20_state.lendingplatform.Client.main(Client.java:5)

状态模式的注意事项和细节

优点

  • 1）代码有很强的可读性：状态模式将每个状态的行为封装到对应的一个类中
  • 2）方便维护：将容易产生问题的if-else语句删除了，如果把每个状态的行为都放到一个类中，每次调用方法时都要判断当前是什么状态，不但会产出很多if-else语句，而且容易出错
  • 3）符合开闭原则，容易增删状态

缺点
会产生很多类：每个状态都要一个对应的类，当状态过多时会产生很多类，加大维护难度

应用场景
当一个事件或者对象有很多种状态，状态之间会相互转换，对不同的状态要求有不同的行为时，可以考虑使用状态模式

Zhang_960110
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java设计模式之状态模式（State模式）介绍
09-03
主要介绍了Java设计模式之状态模式（State模式）介绍,本文讲解了何时使用状态模式、如何使用状态模式等内容,需要的朋友可以参考下
Java设计模式之状态模式
hcyxsh的博客
04-15 186
Java设计模式之状态模式 app抽奖活动问题 请编写程序完成 APP 抽奖活动 具体要求如下: （1) 假如每参加一次这个活动要扣除用户 50 积分，中奖概率是 10% （2) 奖品数量固定，抽完就不能抽奖 （3) 活动有四个状态: 可以抽奖、不能抽奖、发放奖品和奖品领完 （4) 活动的四个状态转换关系图(右图) 状态模式基本介绍 （1）状态模式（State Pattern）：它主要用来解决对象在多种状态转换时，需要对外输出不同的行为的问题。状态和行为是一一对应的，状态之间可以相互转换 （2）当一个对
[状态图]转换代码
m0_48643017的博客
11-29 274
[状态图]转换java代码
Java中23种设计模式
呜呜老司机的博客家园
10-10 7万+
Java中23种设计模式，包括简单介绍，适用场景以及优缺点等
一文讲完Java常用设计模式（全23种）
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
06-10 1万+
设计模式是软件开发中非常有用的工具，可以提高代码的可重用性和可维护性，同时也可以提高开发人员的工作效率。 设计模式有几种类型，包括创建型、结构型和行为型模式。 创建型模式用于以灵活和高效的方式创建对象。包括Singleton模式、工厂模式和抽象工厂模式等。 结构型模式用于组合类和对象以形成更大的结构。包括适配器模式、桥接模式和装饰器模式等。 行为型模式用于处理类或对象之间的通信和控制流。包括观察者模式、策略模式和模板方法模式。
20 状态模式.txt
10-25
20 状态模式.txt
20 状态模式：交通灯.pdf
06-15
JavaScript 设计模式精讲，JavaScript 设计模式精讲，JavaScript 设计模式精讲JavaScript 设计模式精讲JavaScript 设计模式精讲JavaScript 设计模式精讲JavaScript 设计模式精讲JavaScript 设计模式精讲JavaScript ...
Soem-力矩模式(PT)添加代码注释-CSDN.zip
最新发布
03-23
EtherCAT主站SOEM -- 20 --Qt-Soem通过力矩模式（PT）控制一个电机转圈圈这一篇博客的源代码，博客链接（ 正在编写，2024.3发布， https ）。 注意： 该项目源代码提供了 QT-SOEM 配置从站到OP状态，并且对1个...
设计模式--C++
05-27
1.8 怎样使用设计模式 20 第 2 章 实例研究：设计一个文档编辑器 22 2.1 设计问题 23 2.2 文档结构 23 2.2.1 递归组合 24 2.2.2 图元 25 2.2.3 组合模式 272.3 格式化 27 2.3.1 封装格式化算法 27 2.3.2 Compositor ...
23种设计模式 - 各种模式的学习
05-26
23种设计模式 目录 创建型 1. Factory Method（工厂方法） 2. Abstract Factory（抽象工厂） 3. Builder（建造者） 4. Prototype（原型） 5. Singleton（单例） 结构型 6. Adapter Class/Object（适配器） ...
JAVA中23种设计模式
qw_0214的博客
12-23 1192
一、设计模式的分类 总体来说设计模式分为三大类： 创建型模式： 共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式： 共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式： 共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式
Java中常用的设计模式
热门推荐
Superme
03-15 12万+
文章转载借鉴：http://blog.csdn.net/zhangerqing 一、什么是设计模式 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块...
图解Java设计模式（一）
02-27
1) 优秀的程序应该是这样的：阅读时，感觉很优雅；新增功能时，感觉很轻松；运行时，感觉很快速,这就需要设计模式支撑。2) 设计模式包含了大量的编程思想，讲授和真正掌握并不容易，网上的设计模式课程不少，大多讲解的比较晦涩，没有真实的应用场景和框架源码支撑，学习后，只知其形，不知其神。就会造成这样结果: 知道各种设计模式，但是不知道怎么使用到真实项目。本课程针对上述问题，有针对性的进行了升级 (1) 授课方式采用 图解+框架源码分析的方式，让课程生动有趣好理解 (2) 系统全面的讲解了设计模式,包括 设计模式七大原则、UML类图-类的六大关系、23种设计模式及其分类,比如 单例模式的8种实现方式、工厂模式的3种实现方式、适配器模式的3种实现、代理模式的3种方式、深拷贝等3) 如果你想写出规范、漂亮的程序,就花时间来学习下设计模式吧课程内容和目标本课程是使用Java来讲解设计模式，考虑到设计模式比较抽象，授课采用 图解+框架源码分析的方式1) 内容包括: 设计模式七大原则(单一职责、接口隔离、依赖倒转、里氏替换、开闭原则、迪米特法则、合成复用)、UML类图(类的依赖、泛化和实现、类的关联、聚合和组合) 23种设计模式包括：创建型模式：单例模式(8种实现)、抽象工厂模式、原型模式、建造者模式、工厂模式。结构型模式：适配器模式(3种实现)、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式(3种实现)。行为型模式：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter模式）、状态模式、策略模式、职责链模式(责任链模式)2) 学习目标：通过学习，学员能掌握主流设计模式,规范编程风格，提高优化程序结构和效率的能力。
状态模式（State）
王梦杰_MengJie
06-29 3593
状态模式（State Pattern）是一种行为型设计模式，它允许一个对象在其内部状态发生改变时改变其行为，看起来就像是改变了它所属的类。状态模式的核心思想是将对象的状态封装成不同的状态类，对象在不同状态下表现出不同的行为，从而使得对象的行为在不同状态之间更加灵活和可控。
状态模式（State Pattern）
笔记别偷看
12-21 5917
APP 抽奖活动问题 请编写程序完成APP 抽奖活动具体要求如下: 假如每参加一次这个活动要扣除用户50 积分，中奖概率是10% 奖品数量固定，抽完就不能抽奖 活动有四个状态: 可以抽奖、不能抽奖、发放奖品和奖品领完 活动的四个状态转换关系图(下图) 状态模式基本介绍 基本介绍 状态模式（State Pattern）：它主要用来解决对象在多种状态转换时，需要对外输出不同的行为的问题。状态和行为是一一对应的，状态之间可以相互转换 当一个对象的内在状态改变时，允许改变其行为，这个对
Java七种常用设计模式
qq_45196093的博客
04-26 1万+
抽象工厂模式（Abstract Factory Pattern）是Java中常用的一种创建型设计模式，它提供了一种创建一系列相关或相互依赖的对象接口，而无需指定它们具体的类。抽象工厂模式和工厂方法模式类似，不同之处在于抽象工厂模式中工厂类不单独生产一种产品，而是生产一系列相关的产品。定义抽象产品类：void use();定义具体产品类：System . out . println("使用ProductA1");System . out . println("使用ProductA2");
java 常用十种设计模式示例归纳 | 已打包请带走
jingbin_的博客
11-15 3390
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。 GitHub地址DesignPattern文章说明一个Demo，集合常用的十种设计模式，每个模式使用易被人们接受的案例讲述，按模式分包，使用设计模式前后对比，界面显示定义讲解，让你更深刻的了解每种设计模式。 大部分案例来自张鸿洋的博客。如有错误欢迎指正，如有侵权，请联系我删除。##项目结构
Java常见的几种设计模式
guanshengg的博客
08-11 1万+
单例设计模式：一个类只允许创建一个对象（或者实例），那这个类就是一个单例类，这种设计模式就叫做单例设计模式
23种Java设计模式
qq_41847894的博客
03-06 2633
Java 设计模式可以分为三大类：创建型模式 (Creational Patterns)、结构型模式 (Structural Patterns) 、行为型模式 (Behavioral Patterns)。另一类设计模式：J2EE 设计模式。
sudo ./t-rex-64 -i 无状态模式下，正确的打印消息是什么样的
06-13
在T-Rex 无状态模式下，正确的打印消息应该是类似于以下内容： ``` [2021-09-01 20:03:33.073 +0000] [info] Miner core initialized successfully [2021-09-01 20:03:33.073 +0000] [info] 4 miner threads ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值