设计模式之工厂模式

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

目录

工厂模式介绍

工厂模式属于设计模式中的创建型模式。工厂模式提供了一种最佳的创建对象的方式。工厂模式从简单到复杂有三种：简单工厂、工厂方法、抽象工厂。

举例

从一个奶酪的制作到订购的例子开始分析，我们需要集成披萨制作流程，并且声明出披萨的种类。然后再有订购的流程，先写一个不使用设计模式的例子。

package com.lesson4.factory.pizzastore.pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 11:36
 */
public abstract class Pizza
{
    protected String name;

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

    //准备原材料
    public abstract void prepare();

    //烘烤
    public void bake()
    {
        System.out.println(name + " baking;");
    }

    //切割
    public void cut()
    {
        System.out.println(name + " cutting;");
    }

    //打包
    public void box()
    {
        System.out.println(name + " boxing;");
    }
}

准备两种pizza

package com.lesson4.factory.pizzastore.pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 11:40
 */
public class GreekPizza extends Pizza
{
    @Override
    public void prepare()
    {
        System.out.println("给希腊披萨准备原材料");
    }
}


package com.lesson4.factory.pizzastore.pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 11:39
 */
public class CheesePizza extends Pizza
{
    @Override
    public void prepare()
    {
        System.out.println("准备奶酪原材料");
    }
}

订购pizza

package com.lesson4.factory.pizzastore.order;

import com.lesson4.factory.pizzastore.pizza.CheesePizza;
import com.lesson4.factory.pizzastore.pizza.GreekPizza;
import com.lesson4.factory.pizzastore.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 11:42
 */
public class 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.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while (true);
    }

    private String getType(){
        try
        {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 种类：");
            String line = reader.readLine();
            return line;
        } catch (IOException e)
        {
            e.printStackTrace();
            return "";
        }
    }
}

客户端

package com.lesson4.factory.pizzastore.order;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 11:51
 */
public class PizzaStore
{
    public static void main(String[] args)
    {
        new OrderPizza();
    }
}

从上面这个例子可以分析，没有使用设计模式他的优势在于简单，但是劣势在于耦合度太高，而且在OrderPizza类中可能会存在大量判断的现象。

简单工厂模式

  1. 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式

  2. 简单工厂模式:定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)

  3. 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式
    对上面的代码进行部分修改，添加SimpleFactory

package com.lesson4.factory.pizzastore.order;

import com.lesson4.factory.pizzastore.pizza.CheesePizza;
import com.lesson4.factory.pizzastore.pizza.GreekPizza;
import com.lesson4.factory.pizzastore.pizza.Pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 14:31
 */
public class SimpleFactory
{
    public Pizza createPizza(String orderType){
        Pizza pizza = null;
        if(orderType.equals("greek")){
            pizza = new GreekPizza();
            pizza.setName("希腊披萨");
        } else if(orderType.equals("cheese")){
            pizza = new CheesePizza();
            pizza.setName("奶酪披萨");
        }
        return pizza;
    }
}

OrderPizza修改

package com.lesson4.factory.pizzastore.order;

import com.lesson4.factory.pizzastore.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 11:42
 */
public class OrderPizza
{
    public OrderPizza(SimpleFactory simpleFactory)
    {
        setSimpleFactory(simpleFactory);
    }

    SimpleFactory simpleFactory;
    Pizza pizza = null;

    public void setSimpleFactory(SimpleFactory simpleFactory)
    {
        String orderType = "";
        this.simpleFactory = simpleFactory;
        do
        {
            orderType = getType();
            pizza = this.simpleFactory.createPizza(orderType);
            if (pizza != null)
            {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else
            {
                System.out.println("订购失败！");
            }
        } while (true);
    }

    private String getType()
    {
        try
        {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 种类：");
            String line = reader.readLine();
            return line;
        } catch (IOException e)
        {
            e.printStackTrace();
            return "";
        }
    }
}

工厂方法模式

首先依然定义一个抽象的Pizza类

package com.lesson4.factorymethod.pizzastore.pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 11:36
 */
public abstract class Pizza
{
    protected String name;

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

    public abstract void prepare();

    public void bake()
    {
        System.out.println(name + " baking;");
    }

    public void cut()
    {
        System.out.println(name + " cutting;");
    }

    public void box()
    {
        System.out.println(name + " boxing;");
    }
}

然后出四种口味pizza

package com.lesson4.factorymethod.pizzastore.pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 17:23
 */
public class BJCheesePizza extends Pizza
{
    @Override
    public void prepare()
    {
        setName("北京奶酪pizza");
        System.out.println("给北京奶酪pizza准备原材料");
    }
}


package com.lesson4.factorymethod.pizzastore.pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 17:26
 */
public class BJHuJiaoPizza extends Pizza
{
    @Override
    public void prepare()
    {
        setName("北京胡椒pizza");
        System.out.println("给北京胡椒pizza准备原材料");
    }
}


package com.lesson4.factorymethod.pizzastore.pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 17:28
 */
public class LDCheesePizza extends Pizza
{
    @Override
    public void prepare()
    {
        setName("伦敦奶酪pizza");
        System.out.println("给伦敦奶酪pizza准备原材料");
    }
}


package com.lesson4.factorymethod.pizzastore.pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 17:27
 */
public class LDHujiaoPizza extends Pizza
{
    @Override
    public void prepare()
    {
        setName("伦敦胡椒pizza");
        System.out.println("给伦敦胡椒pizza准备原材料");
    }
}

然后是准备订购pizza，这边也是写个抽象类，构造方法写他的实现逻辑

package com.lesson4.factorymethod.pizzastore.order;

import com.lesson4.factorymethod.pizzastore.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 11:42
 */
public abstract class OrderPizza
{
    abstract Pizza createPizza(String orderType);

    public OrderPizza()
    {
        Pizza pizza = null;
        String orderType;
        do
        {
            orderType = getType();
            pizza = createPizza(orderType);

            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();

        } while (true);

    }


    private String getType()
    {
        try
        {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 种类：");
            String line = reader.readLine();
            return line;
        } catch (IOException e)
        {
            e.printStackTrace();
            return "";
        }
    }
}

准备两个继承他的子类

package com.lesson4.factorymethod.pizzastore.order;


import com.lesson4.factorymethod.pizzastore.pizza.BJCheesePizza;
import com.lesson4.factorymethod.pizzastore.pizza.BJHuJiaoPizza;
import com.lesson4.factorymethod.pizzastore.pizza.Pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 17:38
 */
public class BJOrderPizza extends OrderPizza
{
    @Override
    Pizza createPizza(String orderType)
    {
        Pizza pizza = null;
        if(orderType.equals("Cheese")){
            pizza = new BJCheesePizza();
        }else if(orderType.equals("Hujiao")){
            pizza = new BJHuJiaoPizza();
        }
        return pizza;
    }
}


package com.lesson4.factorymethod.pizzastore.order;

import com.lesson4.factorymethod.pizzastore.pizza.LDCheesePizza;
import com.lesson4.factorymethod.pizzastore.pizza.LDHujiaoPizza;
import com.lesson4.factorymethod.pizzastore.pizza.Pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 17:46
 */
public class LDOrderPizza extends OrderPizza
{
    @Override
    Pizza createPizza(String orderType)
    {
        Pizza pizza = null;
        if(orderType.equals("Cheese")){
            pizza = new LDCheesePizza();
        }else if(orderType.equals("Hujiao")){
            pizza = new LDHujiaoPizza();
        }
        return pizza;
    }
}

客户端

package com.lesson4.factorymethod.pizzastore.order;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 11:51
 */
public class PizzaStore
{
    public static void main(String[] args)
    {
        new BJOrderPizza();//实例北京OrderPizza
    }
}

这时候比如输入Cheese控制台会打印

input pizza 种类：
Cheese
给北京奶酪pizza准备原材料
北京奶酪pizza baking;
北京奶酪pizza cutting;
北京奶酪pizza boxing;
input pizza 种类：

根据我的理解，把pizza制作和卖看做两方，首先做pizza过程定义一个抽象类，由具体的子类去继承，order那边同样负责具体的种类的提供。

抽象工厂模式

  1. 抽象工厂模式:定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类

  2. 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。

  3. 从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一 步的抽象)。

  4. 将工厂抽象成两层，AbsFactory(抽象工厂)和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

package com.lesson4.factorymethod.pizzastore.pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 11:36
 */
public abstract class Pizza
{
    protected String name;

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

    public abstract void prepare();

    public void bake()
    {
        System.out.println(name + " baking;");
    }

    public void cut()
    {
        System.out.println(name + " cutting;");
    }

    public void box()
    {
        System.out.println(name + " boxing;");
    }
}

然后出四种口味pizza

package com.lesson4.factorymethod.pizzastore.pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 17:23
 */
public class BJCheesePizza extends Pizza
{
    @Override
    public void prepare()
    {
        setName("北京奶酪pizza");
        System.out.println("给北京奶酪pizza准备原材料");
    }
}


package com.lesson4.factorymethod.pizzastore.pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 17:26
 */
public class BJHuJiaoPizza extends Pizza
{
    @Override
    public void prepare()
    {
        setName("北京胡椒pizza");
        System.out.println("给北京胡椒pizza准备原材料");
    }
}


package com.lesson4.factorymethod.pizzastore.pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 17:28
 */
public class LDCheesePizza extends Pizza
{
    @Override
    public void prepare()
    {
        setName("伦敦奶酪pizza");
        System.out.println("给伦敦奶酪pizza准备原材料");
    }
}


package com.lesson4.factorymethod.pizzastore.pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 17:27
 */
public class LDHujiaoPizza extends Pizza
{
    @Override
    public void prepare()
    {
        setName("伦敦胡椒pizza");
        System.out.println("给伦敦胡椒pizza准备原材料");
    }
}

其实就是把pizza包下面的五个类放进去

order包下，定义一个接口

package com.lesson4.abstractfactory.pizzastore.order;

import com.lesson4.abstractfactory.pizzastore.pizza.Pizza;

//工厂模式抽象层
public interface ABSFactory
{
    Pizza createPizza(String orderType);
}

定义工厂类实现此接口

package com.lesson4.abstractfactory.pizzastore.order;

import com.lesson4.abstractfactory.pizzastore.pizza.BJCheesePizza;
import com.lesson4.abstractfactory.pizzastore.pizza.BJHuJiaoPizza;
import com.lesson4.abstractfactory.pizzastore.pizza.Pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 18:24
 */
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("Hujiao")){
            pizza = new BJHuJiaoPizza();
        }
        return pizza;
    }
}


package com.lesson4.abstractfactory.pizzastore.order;

import com.lesson4.abstractfactory.pizzastore.pizza.LDCheesePizza;
import com.lesson4.abstractfactory.pizzastore.pizza.LDHujiaoPizza;
import com.lesson4.abstractfactory.pizzastore.pizza.Pizza;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 18:24
 */
public class LDFactory implements ABSFactory
{
    @Override
    public Pizza createPizza(String orderType)
    {
        Pizza pizza = null;
        if(orderType.equals("Cheese")){
            pizza = new LDCheesePizza();
        }else if(orderType.equals("Hujiao")){
            pizza = new LDHujiaoPizza();
        }
        return pizza;
    }
}


package com.lesson4.abstractfactory.pizzastore.order;

import com.lesson4.abstractfactory.pizzastore.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 18:31
 */
public class PizzaOrder
{
    ABSFactory factory;

    public PizzaOrder(ABSFactory factory){
        setFactory(factory);
    }

    public void setFactory(ABSFactory factory){
        this.factory = 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);
    }

    private String getType()
    {
        try
        {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 种类：");
            String line = reader.readLine();
            return line;
        } catch (IOException e)
        {
            e.printStackTrace();
            return "";
        }
    }
}

客户端

package com.lesson4.abstractfactory.pizzastore.order;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2020/8/27 11:51
 */
public class PizzaStore
{
    public static void main(String[] args)
    {
        new PizzaOrder(new BJFactory());
    }
}

小结

一、工厂模式的意义
将实例化对象的代码提取出来，放到一个类中统-管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。

二、三种工厂模式(简单工厂模式、工厂方法模式、抽象工厂模式)

三、设计模式的依赖抽象原则：
➢创建对象实例时，不要直接new类，而是把这个new类的动作放在-个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。
➢不要让类继承具体类，而是继承抽象类或者是实现interface(接口)
➢不要覆盖基类中已经实现的方法。

朝花不迟暮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式之工厂模式(C++)
翟天保的博客
02-15 2万+
介绍设计模式之工厂模式
JAVA设计模式之工厂模式（三种工厂模式）
热门推荐
m0_65260253的博客
11-17 2万+
JAVA设计模式之工厂模式（三种工厂模式）
设计模式之工厂模式总结
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 746
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
iOS开发设计模式篇第一篇MVC设计模式
我叫柱子哥
07-22 1056
MVC（Model-View-Controller）是一种常见的软件设计模式，旨在将应用程序的逻辑、用户界面和输入进行分离。在iOS开发中，MVC帮助开发者组织代码，提高可维护性和可扩展性，使得项目结构更加清晰。本文将介绍MVC的基本概念、在iOS中的具体实现、优缺点、实践建议，以及其他常见的架构模式。
设计模式实战：在线购物系统的设计与实现
qq_40254606的博客
07-20 1068
本篇文章将介绍如何设计一个在线购物系统，系统包括购物车、订单处理、支付等功能。我们将通过这一项目，应用组合模式、命令模式、策略模式和观察者模式来解决具体的设计问题。通过本项目，我们综合应用了组合模式、命令模式、策略模式和观察者模式，解决了在线购物系统的设计需求。通过这些模式，我们实现了系统模块的解耦和灵活扩展，使得代码结构更加清晰、易于维护。
Java 和 SpringBoot 中的设计模式 详解
weixin_68074170的博客
07-19 705
假如有一结果api结果返回值的类Person，其在代码中频繁被使用。这两种使用方法的弊端有：（1）：当只需要部分参数的时候需要再定义个构造函数（比如失败的情况只需要code和message，结果肯定是空，因此不需要data），且一旦参数较多，则；（2）；Lombok插件的@Builder注解。
C# 设计模式分类
最新发布
語衣的个人博客
07-23 407
创建型模式主要关注对象的创建过程，包括如何实例化对象，并隐藏实例化的细节。结构型模式主要关注类和对象的组合，以形成更大的结构。行为型模式主要关注对象之间的通信和职责分配。
跟着GPT学设计模式之模板模式
欢迎关注公众号“雨林寻北”，添加个人微信codetrend（备注技术）。
07-19 948
模板模式是一种行为型设计模式，它定义了一个操作中的算法骨架，将一些步骤的具体实现延迟到子类中。该模式使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。
java设计模式：04-行为型模式-概览
Mr_Air_Boy的博客
07-23 489
行为型模式（Behavioral Patterns）主要关注对象之间的通信和职责分配，旨在通过对象之间的相互作用来实现特定的功能。行为型模式不仅关注类和对象的结构，还关注它们之间的协作。通过使用行为型模式，可以提高系统的灵活性和可维护性，减少对象之间的耦合。
设计模式的作用、场景以及示例【快速入门，体验拉满，按需使用】
Dream的博客
07-22 502
设计模式（Design pattern）：是针对设计问题的通用解决方案。 使用设计模式：可以把它应用到特定的应用中，用于解决相似的问题。 使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 真正理解什么是设计模式，就是要透彻理解OO的四大要素：封装、继承、多态和关联。其中核心是封装的概念。
设计模式【点滴积累】
Sumuxi9797926的博客
07-20 967
写在前面，设计模式的核心要义，，要搞清楚我们学习设计模式并不是为了设计模式而学习设计模式，发心是为了让代码更加优雅、美观、健壮。让后来接手的人看到我们构建的“宏伟大厦”，忍不住的说一句：我草，牛B！这里借鉴很久之前看见的一句话，我等采石之人当怀大教堂之理想！（虽然我们是最底层采集石头的人，但是我们还是要有修建教堂的信念；众所周知，中世纪的大教堂，走进去让人深受震撼、宏伟壮观）。学习设计模式之前要先学习六大设计原则，搞懂了这些设计原则，设计模式自然水到渠成。
C++ 设计模式之工厂模式怎么实现
05-16
工厂模式是一种常见的创建型设计模式，用于创建对象，而不是通过直接调用构造函数来创建它们。工厂模式定义了一个接口，用于创建相关对象，但是让子类决定要实例化的类。在C++中，工厂模式可以通过以下步骤实现： 1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值