你能看懂的工厂模式

已于 2022-10-20 09:23:33 修改
阅读量242 收藏 3
点赞数 7
分类专栏： Java基础 设计模式 面试宝典 文章标签： java 设计模式 抽象工厂模式
于 2021-12-21 13:22:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wujiangbo520/article/details/122059821
版权

目录

1、案例需求

2、简单工厂模式

2.1、基本介绍

2.2、编码

3、工厂方法模式

3.1、基本介绍

3.2、编码

4、抽象工厂模式

4.1、基本介绍

4.2、编码

5、总结

5.1、工厂模式的意义

5.2、三种工厂模式

5.3、设计模式的依赖抽象原则

1、案例需求

我们这里以一个具体的需求作为案例进行学习

假如有一个披萨的项目，要便于披萨种类的扩展，便于维护，有以下要求

  1. 披萨的种类有很多种，比如：芝士披萨(CheesePizza)、培根披萨(BaconPizza)、水果披萨(FruitPizza)等等

  2. 披萨的制作有如下阶段：准备原材料(prepare)、烘烤(bake)、切割(cut)、打包(pack)等

  3. 披萨订购功能

现在我们针对上面需求开始编码

首先我们先编写一个Pizza抽象类

package org.colin.factory._01_first;
​
//抽象Pizza类
public abstract class Pizza {
​
    //披萨的名字
    protected String name;
​
    //准备原材料，不同的披萨，那么原材料不一样，因此我们做成抽象方法，实现类具体去选择不同原材料
    public abstract void prepare();
​
    //烘烤
    public void bake(){
        System.out.println("烘烤完成");
    }
​
    //切割
    public void cut(){
        System.out.println("切割完成");
    }
​
    //打包
    public void pack(){
        System.out.println("打包完成");
    }
​
    //设置披萨名字
    public void setName(String name) {
        this.name = name;
    }
}

然后编写不同的种类的披萨类，去继承这个抽象类，并实现抽象方法，先编写芝士披萨类：

package org.colin.factory._01_first;
​
//芝士披萨
public class CheesePizza extends Pizza{
​
    @Override
    public void prepare() {
        System.out.println("给制作【芝士】披萨准备原材料");
    }
}

培根披萨类：

package org.colin.factory._01_first;
​
//培根披萨
public class BaconPizza extends Pizza{
​
    @Override
    public void prepare() {
        System.out.println("给制作【培根】披萨准备原材料");
    }
}

水果披萨类：

package org.colin.factory._01_first;
​
//水果披萨
public class FruitPizza extends Pizza{
​
    @Override
    public void prepare() {
        System.out.println("给制作【水果】披萨准备原材料");
    }
}

接下来是完成披萨订单类，在这里面根据输入的披萨种类的不同来新建不同的披萨对象：

package org.colin.factory._01_first;
​
//订单类接口
public class PizzaController {
​
    public static void main(String[] args) {
        OrderPizza("Cheese");//下一个芝士披萨的订单
    }
​
    //pizzaType：输入披萨种类，返回不同的披萨对象
    public static void OrderPizza(String pizzaType) {
        Pizza pizza = null;
        if (pizzaType.equals("Cheese")){
            //芝士披萨
            pizza = new CheesePizza();
        }else if (pizzaType.equals("Bacon")){
            //培根披萨
            pizza = new BaconPizza();
        }else if (pizzaType.equals("Fruit")){
            //水果披萨
            pizza = new FruitPizza();
        }
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.pack();
    }
}

运行结果：

给制作【芝士】披萨准备原材料
烘烤完成
切割完成
打包完成

将main中OrderPizza参数传入Fruit的话，那就是下一个水果披萨的订单，打印结果如下：

给制作【水果】披萨准备原材料
烘烤完成
切割完成
打包完成

至此我们就完成了所有需求了，大功告成！

但是这样就没有问题了吗？

可以看下上面代码，我们新建披萨的代码编写在披萨订单类里面，所以一旦我们需要扩展一个新的披萨种类的时候，除了需要新建披萨种类的类之外，还需要修改这个披萨订单类，需要加代码，这就违反了开闭原则

此时我们可以考虑使用工厂模式来做

2、简单工厂模式

2.1、基本介绍

  1. 简单工厂模式是属于创建型模式，是工厂模式的一种。

  2. 简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

  3. 简单工厂模式是工厂模式家族中最简单实用的模式。

  4. 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为。

  5. 在软件开发中，当我们会用到大量的创建某种、某类或某批对象时，就会使用到工厂模式。

2.2、编码

那对于上面的案例我们如何使用简单工厂方法来优化呢？ 首先我们需要将披萨订单类PizzaController中生产披萨的代码抽取出来，形成一个简单工厂类：

package org.colin.factory._02_simpleFactory;
​
import org.colin.factory.first.BaconPizza;
import org.colin.factory.first.CheesePizza;
import org.colin.factory.first.FruitPizza;
import org.colin.factory.first.Pizza;
​
//简单工厂模式
public class SimpleFactory {
​
    /**
     * 根据 pizzaType 返回对应的Pizza对象
     * @param pizzaType
     * @return Pizza
     */
    public Pizza createPizza(String pizzaType){
        Pizza pizza = null;
        System.out.println("使用【简单工厂模式】生产披萨.......");
        if (pizzaType.equals("Cheese")){
            //芝士披萨
            pizza = new CheesePizza();
        }else if (pizzaType.equals("Bacon")){
            //培根披萨
            pizza = new BaconPizza();
        }else if (pizzaType.equals("Fruit")){
            //水果披萨
            pizza = new FruitPizza();
        }
        return pizza;
    }
}

订单类PizzaController就可以改成下面这样了：

package org.colin.factory._02_simpleFactory;

import org.colin.factory.first.Pizza;

//订单类接口
public class PizzaController {

    //定义一个简单工厂对象
    private SimpleFactory simpleFactory;

    public PizzaController(SimpleFactory simpleFactory){
        this.simpleFactory = simpleFactory;
    }

    //pizzaType：输入披萨种类，返回不同的披萨对象
    public void OrderPizza(String pizzaType) {
        Pizza pizza = this.simpleFactory.createPizza(pizzaType);
        if(pizza != null){
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.pack();
        }else{
            System.out.println("订购披萨失败");
        }
    }
}

class TestPizza{
    public static void main(String[] args) {
        PizzaController pizzaController = new PizzaController(new SimpleFactory());
        pizzaController.OrderPizza("Cheese");
    }
}

运行结果：

使用【简单工厂模式】生产披萨.......
给制作【芝士】披萨准备原材料
烘烤完成
切割完成
打包完成

这样修改的好处是，如果我们需要扩展新的披萨种类，只需要在简单工厂类(即SimpleFactory类)中更改代码，其它地方不需要进行更改。

接下来对于这个案例，还有一个新需求如下： 客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪Pizza、北京的胡椒Pizza或者是伦敦是奶酪Pizza、伦敦的胡椒Pizza。

这个时候有两种思路：

  1. 使用简单工厂模式，创建不同的简单工厂类，比如BJPizzaSimpleFactory、LDPizzaSImpleFactory等，但是考虑到项目的规模，以及软件的可维护性、可扩展性，这个思路并不是很好

  2. 使用工厂方法模式

3、工厂方法模式

3.1、基本介绍

工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类

对于上述案例的新需求，我们使用工厂方法模式更改，OrderPizza是一个抽象的工厂类，其中的createPizza()方法为抽象方法，然后定义了不同地区口味的披萨工厂类：北京口味披萨工厂类（BJOrderPizza），伦敦口味披萨工厂类（LDOrderPizze），这两个披萨工厂类分别去生产各个地区的披萨，类图如下所示：

3.2、编码

Pizza抽象类还是不变：

package org.colin.factory._03_factoryMethod;

//抽象Pizza类
public abstract class Pizza {

    //披萨的名字
    protected String name;

    //准备原材料，不同的披萨，那么原材料不一样，因此我们做成抽象方法，实现类具体去选择不同原材料
    public abstract void prepare();

    //烘烤
    public void bake(){
        System.out.println("烘烤完成");
    }

    //切割
    public void cut(){
        System.out.println("切割完成");
    }

    //打包
    public void pack(){
        System.out.println("打包完成");
    }

    //设置披萨名字
    public void setName(String name) {
        this.name = name;
    }
}

BJCheesePizza类：

package org.colin.factory._03_factoryMethod;

//北京口味芝士披萨
public class BJCheesePizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("北京口味的【芝士】披萨，正在准备原材料.....");
    }
}

BJBaconPizza类：

package org.colin.factory._03_factoryMethod;

//北京口味培根披萨
public class BJBaconPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("北京口味的【培根】披萨，正在准备原材料.....");
    }
}

BJFruitPizza类：

package org.colin.factory._03_factoryMethod;

//北京口味水果披萨
public class BJFruitPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("北京口味的【水果】披萨，正在准备原材料.....");
    }
}

下面是伦敦口味的三个类：

package org.colin.factory._03_factoryMethod;

//伦敦口味芝士披萨
public class LDCheesePizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("伦敦口味的【芝士】披萨，正在准备原材料.....");
    }
}
package org.colin.factory._03_factoryMethod;

//伦敦口味培根披萨
public class LDBaconPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("伦敦口味的【培根】披萨，正在准备原材料.....");
    }
}
package org.colin.factory._03_factoryMethod;

//伦敦口味水果披萨
public class LDFruitPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("伦敦口味的【水果】披萨，正在准备原材料.....");
    }
}

抽象的工厂类OrderPizza：

package org.colin.factory._03_factoryMethod;

//抽象的工厂类
public abstract class OrderPizza {

    /**
     * 定义一个抽象的方法
     * @param pizzaType
     * @return Pizza
     */
    public abstract Pizza createPizze(String pizzaType);

    public OrderPizza(String orderType) {
        //抽象的方法，由工厂子类完成
        Pizza pizza = createPizze(orderType);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.pack();
    }
}

两个工厂子类分别去实现OrderPizza类：

package org.colin.factory._03_factoryMethod;

//北京口味订单
public class BJOrderPizza extends OrderPizza {

    public BJOrderPizza(String orderType) {
        super(orderType);
    }

    @Override
    public Pizza createPizze(String pizzaType) {
        Pizza pizza = null;
        if (pizzaType.equals("Cheese")){
            //芝士披萨
            pizza = new BJCheesePizza();
        }else if (pizzaType.equals("Bacon")){
            //培根披萨
            pizza = new BJBaconPizza();
        }else if (pizzaType.equals("Fruit")){
            //水果披萨
            pizza = new BJFruitPizza();
        }
        return pizza;
    }
}
package org.colin.factory._03_factoryMethod;

//伦敦口味订单
public class LDOrderPizza extends OrderPizza {

    public LDOrderPizza(String orderType) {
        super(orderType);
    }

    @Override
    public Pizza createPizze(String pizzaType) {
        Pizza pizza = null;
        if (pizzaType.equals("Cheese")){
            //芝士披萨
            pizza = new LDCheesePizza();
        }else if (pizzaType.equals("Bacon")){
            //培根披萨
            pizza = new LDBaconPizza();
        }else if (pizzaType.equals("Fruit")){
            //水果披萨
            pizza = new LDFruitPizza();
        }
        return pizza;
    }
}

测试类：

package org.colin.factory._03_factoryMethod;

public class PizzaTest {

    public static void main(String[] args) {
        //创建北京口味的各种披萨
        new LDOrderPizza("Cheese");
    }
}

4、抽象工厂模式

4.1、基本介绍

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

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

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

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

上面的披萨案例使用抽象工厂模式后类图如下所示：

4.2、编码

接下来我们再来将其实现一下，抽象的工厂接口如下：

package org.colin.factory._04_abstractFactory;

//抽象工厂模式的抽象层
public interface AbsFactory {

    /**
     * 由下面的具体子类实现
     * @param pizzaType
     * @return
     */
    Pizza createPizza(String pizzaType);
}

两个具体的工厂子类：

package org.colin.factory._04_abstractFactory;

//具体的工厂子类
public class BJFactory implements AbsFactory{

    @Override
    public Pizza createPizza(String pizzaType) {
        System.out.println("使用的是抽象工厂模式");
        Pizza pizza = null;
        if (pizzaType.equals("Cheese")){
            //芝士披萨
            pizza = new BJCheesePizza();
        }else if (pizzaType.equals("Bacon")){
            //培根披萨
            pizza = new BJBaconPizza();
        }else if (pizzaType.equals("Fruit")){
            //水果披萨
            pizza = new BJFruitPizza();
        }
        return pizza;
    }
}
package org.colin.factory._04_abstractFactory;

//具体的工厂子类
public class LDFactory implements AbsFactory{

    @Override
    public Pizza createPizza(String pizzaType) {
        System.out.println("使用的是抽象工厂模式");
        Pizza pizza = null;
        if (pizzaType.equals("Cheese")){
            //芝士披萨
            pizza = new LDCheesePizza();
        }else if (pizzaType.equals("Bacon")){
            //培根披萨
            pizza = new LDBaconPizza();
        }else if (pizzaType.equals("Fruit")){
            //水果披萨
            pizza = new LDFruitPizza();
        }
        return pizza;
    }
}

披萨订单类：

package org.colin.factory._04_abstractFactory;

//披萨订单类
public class OrderPizza {

    public AbsFactory absFactory;

    public OrderPizza(AbsFactory absFactory){
        this.absFactory = absFactory;
    }

    public void setOrder(String pizzaType){
        Pizza pizza = this.absFactory.createPizza(pizzaType);
        if (pizza != null){
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.pack();
        }else{
            System.out.println("订购披萨失败");
        }
    }
}

测试类：

package org.colin.factory._04_abstractFactory;

public class Test {

    public static void main(String[] args) {
        //这里演示北京的工厂子类
        OrderPizza orderPizza = new OrderPizza(new BJFactory());
        orderPizza.setOrder("Cheese");
    }
}

运行结果：

使用的是抽象工厂模式
北京口味的【芝士】披萨，正在准备原材料.....
烘烤完成
切割完成
打包完成

5、总结

5.1、工厂模式的意义

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

5.2、三种工厂模式

  • 简单工厂模式

  • 工厂方法模式

  • 抽象工厂模式

5.3、设计模式的依赖抽象原则

  • 创建对象实例时，不要直接new类，而是把这个new类的动作放在一个工厂的方法中，并返回。也可说为：变量不要直接持有具体类的引用。

  • 不要让类继承具体类，而是继承抽象类或者实现interface（接口）。

  • 不要覆盖基类中已经实现的方法。

 

小学生波波
关注
专栏目录
java设计模式7，一看就懂，架构灵魂，工厂方法模式
学Java，找哪吒
08-11 6037
工厂模式也称简单工厂模式，是创建型设计模式的一种，这种设计模式提供了按需创建对象的最佳方式。同时，这种创建方式不会对外暴露创建细节，通常会通过一个统一的接口创建所需对象。
这168个开关电源专业术语，看懂一半的算你牛-综合文档
05-23
2. Ae, 有效区域：在磁芯设计中，有效区域是指能提供相同磁通量的同等材料圆柱形磁芯的横截面积，对于磁路设计至关重要。 3. 周围温度：指的是开关电源工作环境的温度，通常在标准测试条件下4英寸（100mm）远处测量...
看了就懂的工厂模式
转几圈晕
07-30 447
简单工厂模式 简单工厂模式是属于创建型模式， 是工厂模式的一种。 简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式 简单工厂模式： 定义了一个创建对象的类， 由这个类来封装实例化对象的行为(代码) 在软件开发中， 当我们会用到大量的创建某种、 某类或者某批对象时， 就会使用到工厂模式. Uml图: 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。 具体产品角色：工厂
java设计模式详解
熊二吃屁的博客
08-16 354
设计模式的七大原则 设计模式的目的 编写软件过程中，程序员面临着来自 耦合性，内聚性以及可维护性，可扩展性，重 用性，灵活性 等多方面的挑战，设计模式是为了让程序(软件)，具有更好 代码重用性 (即：相同功能的代码，不用多次编写) 可读性 (即：编程规范性, 便于其他程序员的阅读和理解) 可扩展性 (即：当需要增加新的功能时，非常的方便，称为可维护) 可靠性 (即：当我们增加新的功能后，对原来的功能没有影响) 使程序呈现高内聚，低耦合的特性（即：模块内部之间是非常聚合的，模块与模块之间耦合性很低互不影响）
设计模式综述与类图
whjk20的专栏
07-30 314
1. 装饰者模式 2. 建造者模式 2.1 Android AlertDialog (1) AlertDialog 内部静态类Builder ： 创建AlertDialog 对象， 该对象是对AlertController 进行了封装。 (2) AlertDialog 持有产品类AlertController, 该类是用于控件的最终显示， AlertController 是在Android 的内部实现，非SDK (com.android.internal.app.AlertController)
java设计模式——工厂模式
u014627852的博客
06-15 361
简单工厂模式 看一个披萨的项目：要便于披萨种类的扩展，要便于维护 披萨的种类很多(比如 GreekPizz、CheesePizz 等)。 披萨的制作有 prepare，bake, cut, box。 完成披萨店订购功能。 使用传统的方式来完成 思路分析(类图) 编写 OrderPizza.java 去订购需要的各种 Pizza。 2.代码演示： public class OrderPizza { // 构造器 // public OrderPizza() { // Pizza pizza =
一文带你看懂工厂模式（简单工厂，工厂，抽象工厂）
weixin_44664985的博客
06-06 2186
一文带你看懂工厂模式（简单工厂，工厂，抽象工厂）。内附类图、实现代码、优缺点分析、使用场景，通俗易懂。
你还不懂设计模式？ - 抽象工厂模式
zhaodongchao的博客
07-07 1037
抽象工厂模式（Abstract Factory Pattern），顾名思义，是对工厂的抽象。是工厂方法模式的进一步抽象。也可以说是对工厂方法模式的包装。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。 先来看一下UML图： 可以看到，就是使用FactoryCreator来创建不同类型的工厂类。创建了工厂类了之后的逻辑与工厂方法中的一致。有疑问可以去看上一篇工厂方法模式。 这一点还是在日志模块有很好的应用： 如下是org.slf4j.Log
策略模式对比工厂模式
隔窗听雨眠的博客
09-06 1190
策略模式和工厂模式是两种不同的设计模式，它们有不同的目的和使用场景，本文详细说明它们之间的主要区别。
AOC电视进入酒店模式和工厂模式的方法
06-15
测试机型：32m3095（其它机型未试，大同小异，自行测试） 测试时间：2022.06.15 进入酒店模式好处：可以设置通电就开机，可以设置通电用哪一路信号，开机的音量大小，还可以锁定...好多功能，是英文的，我看不懂。
5W字一文带你看懂自动驾驶主流芯片及平台架构 硬件工程师电路分析物联网模电单片机嵌入式技术.doc
09-22
CPU芯片供应商如英特尔、高通等在汽车芯片市场占据重要位置，其中，Mobileye的市场份额虽大，但其封闭交付模式正面临挑战，而华为、地平线等国产厂商有望凭借开放模式赢得更多市场。 在软件层面，操作系统、基础...
教你如何看懂时序图
08-03
通过阅读《教你如何看懂时序图》这份PDF，你可以深入理解时序图的构造、解析方法，以及如何将其应用于实际项目中。同时，配合《怎样读芯片数据手册.pdf》，你将能够更好地掌握硬件系统的交互逻辑，为你的编程和系统...
《Head First 设计模式》之工厂模式（Factory）—— 披萨连锁店
qq_34449717的博客
12-04 2340
目录 一、简单工厂模式 二、工厂方法模式 三、抽象工厂模式 四、总结 工厂模式分为简单工厂模式，工厂方法模式和抽象工厂模式，它们都属于设计模式中的创建型模式。其主要功能都是帮助我们把对象的实例化部分抽取了出来，目的是降低系统中代码耦合度，并且增强了系统的扩展性。本文对这三种模式进行介绍并且分析它们之间的区别。 一、简单工厂模式 1、定义：简单工厂模式是属于创建型模式，又叫做静态工厂方...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 522
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1022
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
qq_36400213的博客
11-04 597
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 389
默认对常规Session的理解和使用，如何使用Set-Cookie。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 209
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
解读555电路图：让你轻松看懂电子方案资料
在电子工程领域，理解电路图是一项基本技能，而555定时器是电子电路设计中常用的集成定时器。本方案资料旨在指导读者如何阅读电路图，并详细解读555定时器在电路中的应用。该资料被压缩在一个ZIP文件中，内容可能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小学生波波

感谢您的厚爱与支持

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值