Head First 设计模式 Design Pattern 附录 Bridge, Builder, Chain, Flyweight, Interpreter

最新推荐文章于 2022-04-13 10:44:13 发布
原创 最新推荐文章于 2022-04-13 10:44:13 发布 · 951 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
Read

当前文章被收录于：

Read
64 篇文章 0 人学习
订阅专栏 查看详情
Design_Pattern

当前文章被收录于：

Design_Pattern
8 篇文章 0 人学习
订阅专栏 查看详情
本文介绍了桥接模式、生成器模式、责任链模式、蝇量模式和解释器模式等五种设计模式，每种模式都提供了详细的优缺点分析及应用场景，并通过示例代码展示了其实现方式。

附录A: 余下的模式

1桥接 Bridge 不只改变实现, 也改变抽象

>优点 将实现解耦 让其和UI之间不再绑定; 抽象和实现可以独立扩展互不影响; 对于"具体的抽象类"所做的改变不影响客户

>用途和缺点 适合需要跨越多个平台的图形和窗口系统上; 当需要用不同的方式改变接口和实现时; 增加了复杂度;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//***********Bridge***********
class ITVImp
{
public:
    virtual void onImp() = 0;
};
                                                                          
class IRemoteControl
{
public:
    virtual void on() = 0;
    virtual void SetImp(ITVImp* pImp) { mpImp = pImp; }
    virtual ITVImp* GetImp() { return mpImp;}
private:
    ITVImp* mpImp;
};
                                                                      
class RCAImp : public ITVImp
{
public:
    virtual void onImp();
};
                                                                      
class ConcreteRemoteControl : public IRemoteControl
{
public:
    ConcreteRemoteControl();
    virtual void on();
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void RCAImp::onImp()
{
    cout << "RCAImp" << endl;
}
                                                                     
ConcreteRemoteControl::ConcreteRemoteControl()
{
    SetImp(new RCAImp());
}
                                                                     
void ConcreteRemoteControl::on()
{
    ((RCAImp*)GetImp())->onImp();
}
                                                                     
        //Bridge
        ConcreteRemoteControl* control = new ConcreteRemoteControl();
        control->on();

PIMPL模式 Private Class Data Pattern 隐藏类的内部实现和数据 用户只能看到public API

2生成器 Builder 封装一个产品的构造过程 允许按步骤构造

>优点 将复杂对象的创建过程封装起来; 允许对象通过多个步骤创建 可以改变过程(工厂模式只有一个步骤); 向客户隐藏产品内部的表现; 产品的表现可替换 客户只看到抽象的接口

>用途和缺点 创建组合结构; 与工厂模式相比 采用生成器创建对象的客户需要具备更多领域知识;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//***********Builder***********
class Result
{
public:
    void show();
    string sPartA;
    string sPartB;
};
                                                  
class IBuilder
{
public:
    virtual void buildA(string a) = 0;
    virtual void buildB(string b) = 0; //...
    virtual Result* getResult() = 0;
};
                                                  
class ResBuilder : public IBuilder
{
public:
    ResBuilder();
    virtual void buildA(string a);
    virtual void buildB(string b);
    virtual Result* getResult() { return mpRes;};
private:
    Result* mpRes;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
ResBuilder::ResBuilder()
{
    mpRes = new Result();
}
                                                  
void ResBuilder::buildA(string a)
{
    mpRes->sPartA = a;
}
                                                  
void ResBuilder::buildB(string b)
{
    mpRes->sPartB = b;
}
                                                  
void Result::show()
{
    cout << sPartA + sPartB << endl;
}
                                                  
        //Builder
        ResBuilder* builder = new ResBuilder();
        builder->buildA("Build part A");
        builder->buildB("Build part B");
        Result* res = builder->getResult();
        res->show();


3责任链 Chain of Responsibility 让一个以上的对象处理某个请求的时候

>优点 将请求的发送者和接收者解耦; 简化对象 使其不需要知道链的结构; 通过改变链内的成员或调动次序 允许动态新增或者删除责任

>用途和缺点 经常使用在窗口系统中 处理鼠标和键盘事件; 不保证请求一定会被执行; 不容易观察运行时的特征, 不易查错

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//***********ChainOR***********
class IHandler;
typedef vector <IHandler*> HANDLERVEC;
class IHandler
{
public:
    IHandler(int iType) : miType(iType) {};
    virtual void handleRequest() = 0;
    virtual int getType() {return miType;}
private:
    int miType;
};
                                      
class ConcreteHandler : public IHandler
{
public:
    ConcreteHandler(int iType);
    virtual void handleRequest();
private:
    HANDLERVEC mHandlerVec;
};
                                      
class HandlerLev1 : public IHandler
{
public:
    HandlerLev1(int iType) : IHandler(iType) {};
    virtual void handleRequest() {cout << "Handle Level1" << endl;};
};
                                      
class HandlerLev2 : public IHandler
{
public:
    HandlerLev2(int iType) : IHandler(iType) {};
    virtual void handleRequest() {cout << "Handle Level2" << endl;};
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
ConcreteHandler::ConcreteHandler(int iType) : IHandler(iType)
{
    HandlerLev1* lev1 =  new HandlerLev1(1);
    HandlerLev2* lev2 =  new HandlerLev2(2);
    mHandlerVec.push_back(lev1);
    mHandlerVec.push_back(lev2);
}
                                     
void ConcreteHandler::handleRequest()
{
    HANDLERVEC::iterator iter = mHandlerVec.begin();
    for (; iter != mHandlerVec.end(); iter++)
    {
        IHandler* handler = *iter;
        if (handler != NULL && getType() == handler->getType())
        {
            handler->handleRequest();
            return;
        }
    }
}
        //ChainOR
        ConcreteHandler* handler = new ConcreteHandler(1);
        handler->handleRequest();


4蝇量 Flyweight 让某个类的一个实例能用来提供很多"虚拟实例" 

>优点 减少运行时对象实例的个数 节省内存; 将许多"虚拟对象"的状态集中管理

>用途和缺点 当类有许多的实例 这些实例能被同一个方法控制的时候; 单个的逻辑实例将无法拥有独立而不同的行为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//***********Flyweight***********
class Tree
{
public:
    Tree(int i);
    virtual void display(int x, int y);
    virtual int getAge() { return miAge;}
private:
    int miAge;
};
                         
struct TreeData
{
    int xCoord;
    int yCoord;
    int age;
};
                         
typedef map <int, Tree*> TREEMAP;
class TreeManager
{
public:
    void displayTrees(int num, TreeData data[]);
    Tree* getTree(int age);
private:
    TREEMAP treeMap;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
Tree::Tree(int i) : miAge(i) {}
                        
void Tree::display(int x, int y)
{
    cout<< "Coord"<< x << ","<< y <<
    "Age"<<miAge<<endl;
}
                        
void TreeManager::displayTrees(int num, TreeData data[])
{
    for(int i = 0; i < num; i++)
    {
        TreeData treeData = data[i];
        getTree(treeData.age)->display(treeData.xCoord, treeData.yCoord);
    }
}
                        
Tree* TreeManager::getTree(int age)
{
    Tree* tree;
    TREEMAP::iterator iter = treeMap.find(age);
    if (iter == treeMap.end()) // Save the memeory
    {
        tree = new Tree(age);
        cout<<"new a tree"<<endl;
        treeMap[age] = tree;
    }
    else
        tree = treeMap[age];
                            
    return tree;
}
        //Flyweight
        TreeData treeData[3] =
        {
            {10, 20, 3},
            {20, 10, 5},
            {30, 30, 3}
        };
        TreeManager treeManager;
        treeManager.displayTrees(3, treeData);


5解释器 Interpreter 为语言创建解释器

>优点 将每一个语法规则表示成一个类; 语法由许多类表示 容易改变或扩展语言; 通过在类结构中加入新的方法 可以在解释的同时增加新的行为 例如格式美化或程序验证

>用途和缺点 需要实现一个简单的语言时; 有一个简单的语法 简单比效率更重要时; 处理脚本语言和编程语言; 当语法规则数目过大时 模式将变得非常繁复 这种情况下适合解析器/编译器


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//***********Interpreter***********
class Context
{
public:
    Context(string s, int d) : statement(s), data(d) {};
    string getState() { return statement;}
    int getData() { return data;}
private:
    string statement;
    int data;
};
             
class IExpression
{
public:
    virtual void Interpreter(Context context) = 0;
};
             
class Expression : public IExpression
{
public:
    void Interpreter(Context context);
    void parseState(string);
    void parseData(int);
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void Expression::Interpreter(Context context)
{
    parseState(context.getState());
    parseData(context.getData());
}
            
void Expression::parseState(string s)
{
    cout << "string: " << s << endl;
}
            
void Expression::parseData(int d)
{
    cout << "data: " << d << endl;
}
        //Interpreter
        Context context("test", 1);
        Expression expression;
        expression.Interpreter(context);

（建造者模式）链式编程之 @Builder 和 @Accessors 学习
南淮北安的博客
04-12 1418
建造者模式：建造者模式又叫创建者模式，是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 创建者模式隐藏了复杂对象的创建过程，它把复杂对象的创建过程加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。 关于 Build的使用可以参考：一篇文章带你使用 Builder 模式实现构建器 文章目录一、@Accessors二、@Builder 和 @Accessors 区别 一、@Accessors 示例： @Data @Accessors(chain = true) p
【HeadFirst 设计模式学习笔记】19 桥接（Bridge）模式拾零
weixin_30496751的博客
12-21 155
作者：gnuhpc 出处：http://www.cnblogs.com/gnuhpc/ 1.概述 该模式也是Head First中未收录的，其主要用于分离接口与实现，常应用在你不希望将实现和抽象永久绑定的时候。其实质在于提供一个对抽象接口的抽象实现，而抽象实现中又包含一个具体实现接口（叫做“实现者”）的引用，通过这个引用给抽象实现提供能力。 2.实例 假设我们要创建一个具有持久化能...
设计模式-建造者模式(Builder)2种实现方式（经典Builder模式、链式Builder模式）
旭东怪的博客
04-13 1291
目录 1 Builder模式 2 经典Builder模式 2.1 抽象建造者角色（Builder） 2.2 具体建造者（ConcreteBuilder） 2.3 指导者（Director） 2.4 产品角色（Product） 2.5 调试代码 3 链式Builder模式 3.1 产品角色（Product） 3.2 调试代码 注： 1 Builder模式 Buidler模式主要分为两种：1、经典Builder模式；2、链式变形Builder模式。 ...
Head First 设计模式 Design Pattern 7-8 Adapter & Facade, Template Method
Fix it
09-08 1667
Section 7 适配器模式和外观模式 Adapter & Facade >客户使用适配器 Client - Request -> Adapter -> TranslateRequest - Adaptee  客户通过目标接口调用适配器的方法发出请求; 适配器使用被适配者的接口把请求转换成被适配者的一个或多个调用接口; 客户收到调用结果, 并不知道是适配器在转化请求 >双向
Head First 设计模式 Design Pattern 1-2 Strategy, Observer
Fix it
07-21 1494
Section 1 策略模式 Strategy 模式:经验复用, 软件开发是在不断调整改变的 设计原则 找出应用中需要变化的部分, 把他们从不需要变化的代码中独立(封装)出来;  >分开变化和不变的部分, 代码变化引起的影响小, 系统有弹性 设计原则 针对接口编程, 不是针对实现编程 >利用接口表示行为, 针对超类型(Supertype)编程, 利用多态 设计原则
Head First 设计模式 Design Pattern 附录 Mediator Memeto Prototype Visitor
Fix it
02-24 1406
附录A: 余下的模式 6中介者 Mediator 集中相关对象之间复杂的沟通和控制方式 每个对象都会在自己的状态改变时告诉中介者; 每个对象都会对中介者发出的请求作出回应; 对象之间解耦; >优点 对象的彼此解耦 增加对象的复用性; 将控制逻辑集中 简化系统维护; 让对象之间传递的信息变的简单轻量 >用途和缺点 用来协调相关的GUI组件; 如果设计不当 中介者对象本身会变得过于复杂
Head First 设计模式 Design Pattern 3-4 Decorator, Factory
Fix it
08-09 1255
Section 3 装饰者模式 Decorator  开放-关闭原则, 只在必须的地方使用开放-关闭原则, 否则增加复杂度, 代码阅读性变差 设计原则 类应该对扩展开放, 对修改关闭 >装饰者和被装饰者对象有相同的超类型 >可以用一个或者多个装饰者包装一个对象 >可以用被装饰过的对象代替原始对象 >装饰者可以在所委托被装饰者的行为之前/后加上自己的行为 >运行时
Head First 设计模式 Design Pattern 5-6 Singleton, Command
Fix it
08-16 1193
Section 5 单件模式 Singleton 创建独一无二的, 只能有一个实例的对象. 延迟实例化 Lazy Instantiaze 单件模式 确保一个类只有一个实例, 并提供一个全局访问点 处理多线程 >Java 利用同步, 缺点是降低性能;    >Java 利用急切 Eagerly方式创建单件, JVM保证在任何线程访问instance之前先
Head First 设计模式 Design Pattern 11-13 Proxy, Combining, For Real
Fix it
01-24 1107
Section 11 代理模式 Proxy 控制和管理访问  代理模式 为另一个对象提供一个替身或占位符以控制对这个对象的访问. 使用代理模式创建代表representative对象, 让代表对象控制某对象的访问, 被代理的对象可以是远程的对象, 创建开销大的对象或需要安全控制的对象. >远程代理Remote Proxy  隐藏远程细节, 调用代理的方法,
Head First 设计模式 Design Pattern 9-10 Iterator and Composite, State
Fix it
11-20 1099
Section 9 迭代器与组合模式 Iterator and Composite 对象超集合 super collection 聚合 aggregate >注意remove()在多线程中的状况   迭代器模式 提供一种方法顺序访问一个聚合对象中的各个元素, 不暴露其内部的表示. >内部迭代器, 外部迭代器, 迭代器的数据结构可以是有序的, 无序的, 重复的. 设计原则
C# WinForm串口工具
07-01
C# WinForm串口工具,.Net8,VS2022
新大陆扫码枪升级文件，固件升级
07-01
NVF800_Factory_V1.01.005.bridge.3.ifp 先更新这个 等重启后，再更新NVF800_Factory_V1.01.005.3.ifp这个 更新完成后需要等几分钟的不能断电，不能拔插
物理信息神经网络PINNs在布洛赫-托雷(Bloch-Torrey)方程上的应用求解 【torch案例】（Python代码实现）
07-01
内容概要：本文系统介绍了物理信息神经网络（PINNs）在求解布洛赫-托雷（Bloch-Torrey）方程中的应用，结合PyTorch框架提供了完整的Python代码实现案例。文章深入阐述了如何将物理先验知识嵌入神经网络训练过程，通过构建复合损失函数，强制网络输出满足控制方程、初始条件与边界条件，从而实现对布洛赫-托雷方程的无网格化、高精度求解。该方法突破了传统数值方法在高维、多尺度及复杂几何场景下的计算瓶颈，展现出优异的泛化能力与计算效率，特别适用于医学成像、扩散磁共振等领域中复杂的物理场建模与仿真任务。; 适合人群：具备深度学习与偏微分方程理论基础，从事科学计算、生物医学工程、材料科学或相关交叉学科研究的研究生、科研人员及算法工程师。; 使用场景及目标：①应用于扩散磁共振成像（dMRI）等医学影像技术中的复杂扩散过程建模与反演；②为高维偏微分方程的高效求解提供数据驱动的新范式，提升仿真精度与计算速度；③作为PINNs在AI for Science领域中的典型实践案例，推动物理引导的深度学习方法在实际科研项目中的落地与拓展。; 阅读建议：建议读者结合提供的完整代码资源（可通过公众号“荔枝科研社”或百度网盘获取），动手复现并调试模型，深入理解PINNs的架构设计、损失函数构建与物理约束嵌入机制，同时可尝试将该方法迁移至其他类似物理系统的建模与求解任务中进行创新性研究。
华为荣耀手机内置铃声为OGG格式
07-01
源码下载地址： https://pan.quark.cn/s/a4b39357ea24 华为荣耀系列移动设备的EMUI操作系统内置了总共76段官方音效，涵盖了诸如Honor、Dream_It_Possible、Huawei_Tune等不同主题的预置音效，这些音效均完整提取自EMUI系统升级包，现向有需求的朋友们进行分享。所有音效文件的格式均为OGG。
基于多VSG独立微网的多目标二次控制MATLAB模型研究（Simulink仿真实现）
07-01
内容概要：本文围绕“基于多VSG独立微网的多目标二次控制MATLAB模型研究”展开，详细阐述了利用Simulink对多虚拟同步发电机（VSG）构成的独立微网系统进行建模与仿真，实现频率调节、电压支撑与有功无功功率均分等多目标协同优化的二次控制策略。研究引入先进的最优控制算法，解决微网在孤岛运行模式下的功率动态分配、频率电压恢复及系统稳定性问题，并通过MATLAB/Simulink平台构建完整仿真模型，验证所提控制策略在不同负载扰动下的有效性、鲁棒性与动态响应性能。; 适合人群：具备电力系统分析、现代控制理论基础以及MATLAB/Simulink仿真能力的电气工程、自动化等相关专业的硕士研究生、科研人员及从事微网控制系统开发的工程技术人才。; 使用场景及目标：① 深入理解多VSG在独立微网中的并联运行机理与协同控制架构；② 掌握基于Simulink的微网二次控制系统的建模方法与仿真流程；③ 实现频率、电压与功率分配的多目标优化控制仿真验证；④ 为微网控制系统的设计、算法优化及科研课题提供可靠的仿真依据和技术参考。; 阅读建议：建议读者结合文中控制策略，动手搭建Simulink模型，重点关注控制器参数整定对系统动态性能的影响，可通过对比不同工况下的仿真结果，进一步优化控制算法以提升系统鲁棒性与响应精度。
无人机视角建筑垃圾倾倒露天垃圾堆放点城市垃圾废弃物检测数据集VOC+YOLO格式3385张6类别.md
07-01
【重要提示】本资源设置为0积分下载，若非0积分请勿轻易下载 亲爱的CSDN用户： 首先感谢你点进这个资源页面。我需要提前说明一个重要情况： 本资源原本已设置为“0积分下载”，即作者希望完全免费共享。但CSDN平台有时会根据文件的下载热度、文件大小、用户权限等因素，自动将部分资源的积分调整为非0数值（如1积分、2积分、5积分等）。这是平台系统的自动行为，而非作者本人的设定。 因此，如果你当前看到该资源的下载所需积分不是0（例如显示为1、2、3……），请谨慎决定是否下载。 如果你按照非0积分支付并下载后发现资源内容不符合预期、链接失效，或者实际上该资源本应是免费的，作者无法为此承担积分损失或退还操作。强烈建议：仅在页面显示为0积分时进行下载。 另外，本资源描述中并未直接提供具体的下载地址或外部链接，因为它本身是一个通过CSDN官方上传通道提交的文件/内容包。如果你看到描述中没有外部网盘地址，这是正常的——资源文件应通过CSDN内置的“下载”按钮获取。若因平台积分显示异常导致你支付了积分，请优先联系CSDN客服咨询积分退还政策，作者没有权限修改平台自动设定的积分值。 感谢你的理解与支持。技术分享本应开放，但受限于平台规则，特此提醒如上。祝学习进步！
windows FastStoneCapture9.6
07-01
windows FastStoneCapture9.6
数据结构实验报告2-栈与队列-队列基本操作算法-实验内容及要求.docx
07-01
代码下载地址： https://pan.quark.cn/s/a4b39357ea24 编写程序，建立容量为n(建议n=8)的循环队列，完成以下程序功能。 输入字符#，执行一次出队操作，屏幕上显示出队字符；输入字符@，队列中所有字符依次出队并按出队次序在屏幕上显示各字符；输入其它字符，则输入的字符入队。 要求采用队头/队尾间隔至少一个空闲元素的方法来实现循环队列；空队执行出队操作及队满执行入队操作需显示提示信息。 ### 数据结构实验报告知识点 #### 实验背景与目标 本次实验是关于数据结构中的队列基本操作算法。 队列是一种先进先出（FIFO）的数据结构，在计算机科学中有着广泛的应用，例如进程调度、任务队列等场景。 通过本实验，学生能够深入理解循环队列的概念，并熟练掌握其实现方法。 #### 实验要求与内容 1. **实验内容**：要求编写一个程序来建立容量为 _n_ 的循环队列（推荐 _n_ = 8），并实现以下功能： - 输入字符 `#` 执行一次出队操作，并显示该出队字符； - 输入字符 `@`，将队列中的所有字符依次出队，并按照出队顺序在屏幕上显示这些字符； - 输入其他任意字符，则将该字符入队。 2. **特殊要求**： - 采用队头/队尾间隔至少一个空闲元素的方法实现循环队列，这样可以避免队列的物理连续性与逻辑连续性的混淆，同时便于检测队列是否为空或满。 - 当队列为满时尝试执行入队操作，或者队列为时空执行出队操作时，需要给出相应的提示信息。 3. **注意事项**： - 在反复输入字符时，应妥善处理输入缓冲区中的回车键（即 `\n` 字符）的问题，避免因连续输入导致的错误行为。 #### 数据结构设计 为了实现上述要求，本实验采用了如下的数据结构设计： ...
基于数据驱动的 Koopman 算子的递归神经网络模型线性化，用于纳米定位系统的预测控制研究（Matlab代码实现）
最新发布
07-01
内容概要：本文提出了一种基于数据驱动的Koopman算子与递归神经网络（RNN）相结合的模型线性化方法，用于提升纳米定位系统的预测控制性能。该方法通过Koopman算子将复杂的非线性系统动态映射至高维线性空间，克服传统建模在强非线性条件下的局限性，再结合RNN强大的时序特征捕捉能力，实现对系统未来状态的高精度预测与有效控制。整个框架完全基于数据驱动，无需精确物理建模，特别适用于原子力显微镜、半导体制造等对定位精度要求极高的应用场景，并通过Matlab代码实现了算法的完整仿真与验证。; 适合人群：具备控制理论基础和Matlab编程能力，从事精密运动控制、智能算法开发、非线性系统建模与预测控制研究的研究生、科研人员及工程技术开发者。; 使用场景及目标：①解决纳米级定位平台中存在的强非线性、迟滞、蠕变等复杂动态特性带来的控制难题；②为高精度机电系统提供一种可复现、易实现的数据驱动预测控制方案；③推动Koopman理论与深度学习在先进制造与智能控制领域的深度融合与应用创新。; 阅读建议：建议读者结合提供的Matlab代码深入理解Koopman算子的数值实现流程与RNN网络结构设计细节，重点关注模型在不同工况下的泛化能力、实时性表现及控制稳定性，可进一步将其拓展至其他高精度伺服控制系统的研究与优化中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值