设计模式之工厂模式

最新推荐文章于 2024-07-22 22:58:19 发布
最新推荐文章于 2024-07-22 22:58:19 发布
阅读量508 收藏
点赞数
分类专栏： 设计模式 文章标签： java 设计模式 工厂方法模式 抽象工厂模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38854703/article/details/121494135
版权

工厂模式

需求

要求便于披萨种类的扩展,便于维护

  1. 披萨的种类很多
  2. 披萨的制作有 prepare, bake, cut, box
  3. 完成披萨店订购功能

传统方式

类图

类图

代码

/**
 * @Classname Pizza
 * @Description
 * @Date 2021/9/28 14:12
 * @Author Yzx
 */
public class Pizza {

    private String name;

    void prepare(){
        System.out.println(name + " 披萨准备工作");
    }
    void bake(){
        System.out.println(name + " 披萨烘烤工作");
    }
    void cut(){
        System.out.println(name + " 披萨切割工作");
    }
    void box(){
        System.out.println(name + " 披萨装盒工作");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

/**
 * @Classname GreenPizza
 * @Description
 * @Date 2021/9/28 14:34
 * @Author Yzx
 */
public class GreekPizza extends Pizza{

}

/**
 * @Classname CheesePizza
 * @Description
 * @Date 2021/9/28 14:36
 * @Author Yzx
 */
public class CheesePizza extends Pizza{

}

/**
 1. @Classname OrderPizza
 2. @Description
 3. @Date 2021/9/28 14:37
 4. @Author Yzx
 */
public class OrderPizza {

    public static void main(String[] args) {
        new OrderPizza();
    }

    public OrderPizza() {

        Pizza pizza = null;
        String orderType; //  订购披萨的类型
        do {
            orderType = getType();
            if (orderType.equals("greek")) {
                pizza = new GreekPizza();
                pizza.setName(" 希腊披萨 ");
            } else if (orderType.equals("cheese")) {
                pizza = new CheesePizza();
                pizza.setName(" 奶酪披萨 ");
            } else {
                break;
            }
            //输出 pizza 制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();

        } while (true);
    }

    /**
     * 获取客户希望订购的披萨种类
     * @return 类型
     */
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 种类:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

优缺点

  1. 代码容易理解
  2. 违反了设计模式的对外扩展开放, 对修改关闭原则, 当我们给类增加新功能时, 尽量不修改代码, 或尽可能减少修改量
  3. 当需要新增一个披萨种类时, 只要是订购披萨的代码需要修改

改进

把创建pizza对象封装到一个类中, 当有新的种类时, 只需要修改这个类就可以, 其他创建pizza对象的代码就不需要修改, 也就是简单工厂模式

简单工厂

由一个工厂对象决定创建哪种产品累的实例, 是工厂模式中最简单使用的模式

类图

类图

代码

/**
 * @Classname Pizza
 * @Description
 * @Date 2021/9/28 14:12
 * @Author Yzx
 */
public class Pizza {

    private String name;

    void prepare(){
        System.out.println(name + " 披萨准备工作");
    }
    void bake(){
        System.out.println(name + " 披萨烘烤工作");
    }
    void cut(){
        System.out.println(name + " 披萨切割工作");
    }
    void box(){
        System.out.println(name + " 披萨装盒工作");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

/**
 * @Classname CheesePizza
 * @Description
 * @Date 2021/9/28 14:36
 * @Author Yzx
 */
public class CheesePizza extends Pizza {

}

/**
 * @Classname GreenPizza
 * @Description
 * @Date 2021/9/28 14:34
 * @Author Yzx
 */
public class GreekPizza extends Pizza {

}

/**
 * @Classname SimpleFactory
 * @Description
 * @Date 2021/9/28 15:29
 * @Author Yzx
 */
public class SimpleFactory {

    public static Pizza createPizza(String orderType) {
        Pizza pizza = null;

        System.out.println("使用简单工厂模式");
        if (orderType.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName(" 希腊披萨 ");
        } else if (orderType.equals("cheese")) {
            pizza = new CheesePizza();
            pizza.setName(" 奶酪披萨 ");
        }

        return pizza;
    }

}

/**
 * @Classname OrderPizza
 * @Description
 * @Date 2021/9/28 14:37
 * @Author Yzx
 */
public class OrderPizza {

    public static void main(String[] args) {
        new OrderPizza();
    }

    public OrderPizza() {
        //用户输入的
        String orderType = "";
        Pizza pizza = null;
        do {
            orderType = getType();
            pizza = SimpleFactory.createPizza(orderType);
            //输出 pizza
            if (pizza != null) {
                //订购成功
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println(" 订购披萨失败 ");
                break;
            }
        } while (true);
    }

    /**
     * 获取客户希望订购的披萨种类
     *
     * @return 类型
     */
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 种类:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

工厂方法模式

新需求

客户在点披萨时, 可以点不同口味的披萨, 如北京的奶酪披萨, 北京的胡椒披萨或伦敦的奶酪披萨等

思路

使用简单工厂模式, 创建不同的简单工厂类, 当有许多地市口味时, 软件的可维护性, 扩展性不好, 可以使用工厂方法模式

类图

类图

代码

/**
 * @Classname Pizza
 * @Description
 * @Date 2021/9/28 14:12
 * @Author Yzx
 */
public class Pizza {

    private String name;

    void prepare(){
        System.out.println(name + " 披萨准备工作");
    }
    void bake(){
        System.out.println(name + " 披萨烘烤工作");
    }
    void cut(){
        System.out.println(name + " 披萨切割工作");
    }
    void box(){
        System.out.println(name + " 披萨装盒工作");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

/**
 * @Classname BJCheessPizza
 * @Description
 * @Date 2021/9/28 17:20
 * @Author Yzx
 */
public class BJCheesePizza extends Pizza{
    public BJCheesePizza() {
        this.setName("北京");
    }
}

/**
 * @Classname BJPepperPizza
 * @Description
 * @Date 2021/9/28 17:20
 * @Author Yzx
 */
public class BJPepperPizza extends Pizza{
    public BJPepperPizza() {
        this.setName("北京");
    }
}

/**
 * @Classname BJOrderPizza
 * @Description
 * @Date 2021/9/28 17:23
 * @Author Yzx
 */
public class BJOrderPizza extends OrderPizza {

    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}

/**
 * @Classname BJCheessPizza
 * @Description
 * @Date 2021/9/28 17:20
 * @Author Yzx
 */
public class LDCheesePizza extends Pizza{
    public LDCheesePizza() {
        this.setName("伦敦");
    }
}

/**
 * @Classname BJPepperPizza
 * @Description
 * @Date 2021/9/28 17:20
 * @Author Yzx
 */
public class LDPepperPizza extends Pizza{
    public LDPepperPizza() {
        this.setName("伦敦");
    }
}

/**
 * @Classname BJOrderPizza
 * @Description
 * @Date 2021/9/28 17:23
 * @Author Yzx
 */
public class LDOrderPizza extends OrderPizza {

    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new LDPepperPizza();
        } else if (orderType.equals("pepper")) {
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

/**
 * @Classname OrderPizza
 * @Description
 * @Date 2021/9/28 14:37
 * @Author Yzx
 */
public abstract class OrderPizza {

    public static void main(String[] args) {
        new BJOrderPizza();
        //new LDPepperPizza();
    }

    /**
     * 创建披萨
     * @param orderType
     * @return
     */
    abstract Pizza createPizza(String orderType);

    public OrderPizza() {

        Pizza pizza = null;
        String orderType; //  订购披萨的类型
        do {
            orderType = getType();
            pizza = createPizza(orderType);
            if (pizza != null) {
                //订购成功
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println(" 订购披萨失败 ");
                break;
            }

        } while (true);
    }

    /**
     * 获取客户希望订购的披萨种类
     * @return 类型
     */
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 种类:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

抽象工厂

抽象工厂模式就是对简单工厂模式的改进, 可以将简单工厂模式和工厂方法模式进行整合
将工厂抽象成两层, 抽象工厂和具体实现的工厂子类, 可以根据创建对象类型使用对应的工厂子类, 将单个的简单工厂类变成工厂簇, 便于代码的维护和扩展

类图

类图

代码

/**
 * @Classname Pizza
 * @Description
 * @Date 2021/9/28 14:12
 * @Author Yzx
 */
public class Pizza {

    private String name;

    void prepare(){
        System.out.println(name + " 披萨准备工作");
    }
    void bake(){
        System.out.println(name + " 披萨烘烤工作");
    }
    void cut(){
        System.out.println(name + " 披萨切割工作");
    }
    void box(){
        System.out.println(name + " 披萨装盒工作");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

/**
 * @Classname BJCheessPizza
 * @Description
 * @Date 2021/9/28 17:20
 * @Author Yzx
 */
public class BJCheesePizza extends Pizza {
    public BJCheesePizza() {
        this.setName("北京");
    }
}

/**
 * @Classname BJPepperPizza
 * @Description
 * @Date 2021/9/28 17:20
 * @Author Yzx
 */
public class BJPepperPizza extends Pizza {
    public BJPepperPizza() {
        this.setName("北京");
    }
}

/**
 * @Classname BJCheessPizza
 * @Description
 * @Date 2021/9/28 17:20
 * @Author Yzx
 */
public class LDCheesePizza extends Pizza {
    public LDCheesePizza() {
        this.setName("伦敦");
    }
}

/**
 * @Classname BJPepperPizza
 * @Description
 * @Date 2021/9/28 17:20
 * @Author Yzx
 */
public class LDPepperPizza extends Pizza {
    public LDPepperPizza() {
        this.setName("伦敦");
    }
}

/**
 * @Classname AbsFactory
 * @Description
 * @Date 2021/9/29 14:30
 * @Author Yzx
 */
public interface AbsFactory {
    Pizza createPizza(String orderType);
}

/**
 * @Classname BJOrderPizza
 * @Description
 * @Date 2021/9/28 17:23
 * @Author Yzx
 */
public class BJFactory implements AbsFactory {

    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}

/**
 * @Classname BJOrderPizza
 * @Description
 * @Date 2021/9/28 17:23
 * @Author Yzx
 */
public class LDFactory implements AbsFactory {

    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new LDPepperPizza();
        } else if (orderType.equals("pepper")) {
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

/**
 * @Classname OrderPizza
 * @Description
 * @Date 2021/9/28 14:37
 * @Author Yzx
 */
public class OrderPizza {

    public static void main(String[] args) {
        new OrderPizza(new BJFactory());
        //new OrderPizza(new LDFactory());
    }


    public OrderPizza(AbsFactory factory) {

        Pizza pizza = null;
        String orderType; //  订购披萨的类型
        do {
            orderType = getType();
            pizza = factory.createPizza(orderType);
            if (pizza != null) {
                //订购成功
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println(" 订购披萨失败 ");
                break;
            }

        } while (true);
    }

    /**
     * 获取客户希望订购的披萨种类
     * @return 类型
     */
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 种类:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

小结

工厂模式意义

将实例化对象的提取出来, 放到一个类中统一管理与维护, 达到和主项目的依赖关系的解耦, 从而提高项目的扩展性和维护性

设计模式依赖抽象原则

  • 创建对象实例时, 不要直接 new 类, 而是把这个new类的动作放到一个工厂的方法中, 并返回. 变量不要直接持有具体类的引用
  • 不要让类继承具体类, 二十继承抽象类或实现接口
  • 不要覆盖基类中已经实现的方法
始末丶Yzx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式之工厂模式总结
12-21
编辑Java笔记");}}增加Python笔记public ...设计模式是软件开发中的宝贵经验总结，工厂模式作为其中的一员，可以帮助我们编写更加灵活、可维护的代码。理解并熟练运用工厂模式，能够提升软件设计的质量和可扩展性。
Java设计模式之工厂模式
08-27
Java设计模式之工厂模式是Java设计模式中的一种，主要用于解决不同类型数据采集的接口问题。该模式通过定义一个工厂接口，提供不同的数据采集类实现该接口，并通过工厂类来获取不同的数据采集类对象，从而隐藏了new...
Java设计模式之工厂模式实现方法详解
08-28
Java设计模式之工厂模式实现方法详解 工厂模式是 Java 设计模式中的一种重要模式，它提供了一种创建对象的接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。工厂模式主要有三种：简单工厂模式、...
设计模式之工厂模式1
08-08
工厂模式是一种设计模式，属于创建型模式，它的主要目的是通过提供一个统一的接口来创建对象，使得客户端在使用时不需要关心具体的对象实例化过程。在工厂模式中，一个工厂类负责创建对象，而具体创建哪种类型的对象...
PHP设计模式之工厂模式定义与用法详解
12-20
【工厂模式】是一种常见的设计模式，它属于创建型模式，主要目标是提供一个创建对象的接口，隔离了实例化过程，使得系统对扩展开放而对修改封闭。在PHP中，工厂模式的应用能帮助我们更好地管理和控制对象的创建。 ...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 743
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 694
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 713
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1241
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1271
JVM-垃圾回收与内存分配
【Java算法】前缀和 下
2302_79806056的博客
07-18 1124
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1104
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
最新发布
Aishangyuwen的博客
07-22 835
Java实现拼图小游戏
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 926
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 671
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
javaScrip的学习（一）
weixin_65450681的博客
07-19 1274
这篇文章让我们简单来了解一下js，那么什么是js?JavaScript（简称JS）是一种高级编程语言，主要用于为网页添加交互功能。它可以嵌入到HTML页面中，通过对DOM（文档对象模型）的操作来实现动态效果和用户交互。JavaScript由Netscape公司的Brendan Eich于1995年创造，最初是为了增强HTML页面的功能性。随着时间的推移，JavaScript逐渐演变成一种通用的编程语言，可以在浏览器以外的环境中运行，例如服务器端的Node.js。
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 544
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
每 日练 习
m0_67187271的博客
07-19 1044
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
《简历宝典》15 - 简历中“项目经历”，实战讲解，Java篇
xingyu_qie的专栏
07-18 248
校招和初级Java开发的项目经历重点是突出自己在实战中的学习。比如对数据库的操作，比如前后端联调工作中遇到问题的解决，比如一些Java基础知识点的逐渐深入掌握，这些都是这个阶段的Java开发需要去不断增强的。和初级前端开发类似，例如你作为一名初级Java开发，负责的是校园图书管理系统的图书信息上传，图书信息管理这个模块的服务端开发，项目经历可以这样编写，如图。
C++ 设计模式之工厂模式怎么实现
05-16
工厂模式是一种常见的创建型设计模式，用于创建对象，而不是通过直接调用构造函数来创建它们。工厂模式定义了一个接口，用于创建相关对象，但是让子类决定要实例化的类。在C++中，工厂模式可以通过以下步骤实现： 1. 创建一个抽象基类，该类定义了一个纯虚拟函数，该函数将返回一个指向基类的指针。这个基类就是我们的工厂接口。 ```c++ class Product { public: virtual ~Product() {} virtual void operation() = 0; }; ``` 2. 创建具体的产品类，它们继承自抽象基类，并实现了其纯虚拟函数。这些类就是我们的具体产品。 ```c++ class ConcreteProductA : public Product { public: void operation() override { /* 具体产品 A 的操作 */ } }; class ConcreteProductB : public Product { public: void operation() override { /* 具体产品 B 的操作 */ } }; ``` 3. 创建一个工厂类，该类实现了工厂接口，并根据需要创建具体的产品。这个工厂类就是我们的具体工厂。 ```c++ class Factory { public: virtual ~Factory() {} virtual std::unique_ptr<Product> createProduct() = 0; }; class ConcreteFactoryA : public Factory { public: std::unique_ptr<Product> createProduct() override { return std::make_unique<ConcreteProductA>(); } }; class ConcreteFactoryB : public Factory { public: std::unique_ptr<Product> createProduct() override { return std::make_unique<ConcreteProductB>(); } }; ``` 4. 在客户端代码中使用具体工厂创建具体产品。 ```c++ int main() { std::unique_ptr<Factory> factory = std::make_unique<ConcreteFactoryA>(); std::unique_ptr<Product> product = factory->createProduct(); product->operation(); return 0; } ``` 这就是工厂模式的基本实现方式。通过这种方式，我们可以将对象的创建过程与客户端代码分离，从而更好地实现模块化和可扩展性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值