设计模式——4. 建造者模式

已于 2023-10-08 23:02:56 修改
阅读量273 收藏
点赞数
分类专栏： 设计模式大全 文章标签： 设计模式 建造者模式 java python golang javascript c++
于 2023-09-25 14:27:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guohuang/article/details/133269431
版权

1. 说明

建造者模式（Builder Pattern）是一种创建型设计模式，旨在将一个复杂对象的构建过程与其表示分离，以便可以使用相同的构建过程来创建不同的表示。它允许你逐步构建一个复杂对象，同时保持构建过程的灵活性。

建造者模式通常包含以下角色：

  1. Director（指导者）：Director负责调用建造者来构建复杂对象。它并不直接构建对象，而是将构建任务委派给建造者。
  2. Builder（建造者）：建造者接口声明了创建复杂对象的方法。具体的建造者类实现了这个接口，负责实际构建对象的各个部分。
  3. ConcreteBuilder（具体建造者）：具体建造者实现了建造者接口，它负责构建对象的各个部分，并提供方法来设置这些部分的属性。
  4. Product（产品）：产品是由建造者构建的复杂对象。它通常包含多个部分，这些部分在构建过程中由不同的具体建造者来设置。

建造者模式的主要优点包括：

  • 分离复杂对象的构建过程，使代码更易于理解和维护。
  • 允许使用相同的构建过程创建不同的对象变体。
  • 可以控制构建过程的细节，从而灵活地创建不同配置的对象。

2. 使用的场景

建造者模式在以下情况下特别有用：

  1. 需要创建复杂对象：当需要创建的对象非常复杂，包含多个部分和配置选项时，建造者模式可以将构建过程分解为多个步骤，使得代码更具可维护性。
  2. 对象的构建过程可变或可配置：如果对象的构建过程涉及多个步骤，并且这些步骤中的一些是可变的或可配置的，建造者模式使得在构建对象时可以根据需要进行定制。
  3. 需要创建不同表示的相同对象：建造者模式允许使用相同的构建过程创建不同表示的对象，从而支持多种对象变体的创建。
  4. 避免构造函数参数过多：当一个类的构造函数需要大量参数时，使用建造者模式可以减少构造函数的参数数量，使代码更清晰，同时还能提供有意义的方法名称来设置属性。
  5. 需要创建不可变对象：在某些情况下，需要确保创建的对象是不可变的，这可以通过在建造者模式中设置对象的属性后将其锁定来实现。
  6. 提供链式调用：建造者模式通常使用方法链式调用，这可以使代码更具表现力和可读性，因为可以按照自然语言的方式设置对象的属性。
  7. 分离构建过程和表示：建造者模式将对象的构建过程与其表示分离，这有助于实现单一职责原则，每个具体建造者负责不同的构建细节。

典型的应用场景包括创建文档对象、游戏中的角色创建、配置对象的构建、图形用户界面中的窗口构建以及复杂产品的制造等。建造者模式使得这些场景中的对象构建更灵活、可维护和可扩展。

3. 应用例子

下面是一个使用Python实现的建造者模式的示例，其中我们创建了一个电脑对象，该电脑具有多个配置选项，如CPU、内存和存储：

# 创建产品类：电脑
class Computer:
    def __init__(self):
        self.cpu = None
        self.memory = None
        self.storage = None

    def __str__(self):
        return f"Computer: CPU={self.cpu}, Memory={self.memory}, Storage={self.storage}"

# 创建抽象建造者接口
class ComputerBuilder:
    def set_cpu(self, cpu):
        pass

    def set_memory(self, memory):
        pass

    def set_storage(self, storage):
        pass

    def get_computer(self):
        pass

# 创建具体建造者类：高性能电脑建造者
class HighPerformanceComputerBuilder(ComputerBuilder):
    def set_cpu(self, cpu):
        self.computer.cpu = "High-Performance " + cpu

    def set_memory(self, memory):
        self.computer.memory = "16GB " + memory

    def set_storage(self, storage):
        self.computer.storage = "1TB SSD " + storage

    def get_computer(self):
        return self.computer

# 创建具体建造者类：普通电脑建造者
class StandardComputerBuilder(ComputerBuilder):
    def set_cpu(self, cpu):
        self.computer.cpu = "Standard " + cpu

    def set_memory(self, memory):
        self.computer.memory = "8GB " + memory

    def set_storage(self, storage):
        self.computer.storage = "256GB SSD " + storage

    def get_computer(self):
        return self.computer

# 创建指导者类：电脑销售员
class ComputerSalesman:
    def __init__(self):
        self.builder = None

    def set_builder(self, builder):
        self.builder = builder

    def construct_computer(self, cpu, memory, storage):
        self.builder.set_cpu(cpu)
        self.builder.set_memory(memory)
        self.builder.set_storage(storage)
        return self.builder.get_computer()

# 客户端代码
if __name__ == "__main__":
    salesman = ComputerSalesman()

    # 构建高性能电脑
    high_performance_builder = HighPerformanceComputerBuilder()
    salesman.set_builder(high_performance_builder)
    high_performance_computer = salesman.construct_computer("Intel i7", "Corsair", "Samsung")
    print(high_performance_computer)

    # 构建普通电脑
    standard_builder = StandardComputerBuilder()
    salesman.set_builder(standard_builder)
    standard_computer = salesman.construct_computer("Intel i3", "Kingston", "Seagate")
    print(standard_computer)

在这个示例中：

  • Computer 是产品类，表示要构建的电脑对象。
  • ComputerBuilder 是抽象建造者接口，声明了设置CPU、内存和存储的方法以及获取电脑对象的方法。
  • HighPerformanceComputerBuilder 和 StandardComputerBuilder 是具体建造者类，分别用于构建高性能电脑和普通电脑。
  • ComputerSalesman 是指导者类，负责协调建造过程，根据客户需求选择合适的建造者来构建电脑。

客户端代码演示了如何使用建造者模式来构建不同配置的电脑对象。通过设置不同的建造者，可以构建出高性能电脑和普通电脑，而不需要直接操作产品类的构造函数或属性。这使得创建复杂对象更加灵活和可维护。

4. 实现要素

建造者模式的实现要素包括以下几个部分：

  1. 产品类（Product）：产品是最终要构建的复杂对象，通常包含多个部分或属性。产品类定义了这些属性以及可能的操作。
  2. 抽象建造者接口（Builder）：抽象建造者接口声明了构建产品的各个部分的抽象方法，例如设置CPU、内存、存储等。具体的建造者类将实现这些方法以构建产品。
  3. 具体建造者类（ConcreteBuilder）：具体建造者类实现了抽象建造者接口，负责实际构建产品的各个部分，并提供方法来设置这些部分的属性。具体建造者类通常与一个特定的产品类型相关联。
  4. 指导者类（Director）：指导者类负责调用建造者来构建复杂对象。它了解构建产品所需的顺序和步骤，但不直接构建对象。
  5. 客户端（Client）：客户端代码负责创建指导者和建造者对象，并使用指导者来构建产品。客户端通常知道所需产品的类型，然后选择适当的具体建造者来构建产品。

5. UML图

在这里插入图片描述
在这个UML类图中：

  • Product 是最终要构建的产品类，它具有各个部分或属性。
  • Builder 是抽象建造者接口，声明了构建产品的方法。
  • ConcreteBuilder 是具体建造者类，它们实现了 Builder 接口，并负责构建具体产品。
  • Director 是指导者类，负责协调建造过程，通常包括了知道构建产品的顺序和步骤。

6. Java/golang/javascrip/C++ 等语言实现方式

6.1 Java实现

上述例子用Java语言实现示例如下：

// 创建产品类：电脑
class Computer {
    private String cpu;
    private String memory;
    private String storage;

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public void setStorage(String storage) {
        this.storage = storage;
    }

    @Override
    public String toString() {
        return "Computer: CPU=" + cpu + ", Memory=" + memory + ", Storage=" + storage;
    }
}

// 创建抽象建造者接口
interface ComputerBuilder {
    void setCpu();
    void setMemory();
    void setStorage();
    Computer getComputer();
}

// 创建具体建造者类：高性能电脑建造者
class HighPerformanceComputerBuilder implements ComputerBuilder {
    private Computer computer = new Computer();

    @Override
    public void setCpu() {
        computer.setCpu("High-Performance Intel i7");
    }

    @Override
    public void setMemory() {
        computer.setMemory("16GB Corsair");
    }

    @Override
    public void setStorage() {
        computer.setStorage("1TB SSD Samsung");
    }

    @Override
    public Computer getComputer() {
        return computer;
    }
}

// 创建具体建造者类：普通电脑建造者
class StandardComputerBuilder implements ComputerBuilder {
    private Computer computer = new Computer();

    @Override
    public void setCpu() {
        computer.setCpu("Standard Intel i3");
    }

    @Override
    public void setMemory() {
        computer.setMemory("8GB Kingston");
    }

    @Override
    public void setStorage() {
        computer.setStorage("256GB SSD Seagate");
    }

    @Override
    public Computer getComputer() {
        return computer;
    }
}

// 创建指导者类：电脑销售员
class ComputerSalesman {
    private ComputerBuilder builder;

    public void setBuilder(ComputerBuilder builder) {
        this.builder = builder;
    }

    public Computer constructComputer() {
        builder.setCpu();
        builder.setMemory();
        builder.setStorage();
        return builder.getComputer();
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        ComputerSalesman salesman = new ComputerSalesman();

        // 构建高性能电脑
        ComputerBuilder highPerformanceBuilder = new HighPerformanceComputerBuilder();
        salesman.setBuilder(highPerformanceBuilder);
        Computer highPerformanceComputer = salesman.constructComputer();
        System.out.println(highPerformanceComputer);

        // 构建普通电脑
        ComputerBuilder standardBuilder = new StandardComputerBuilder();
        salesman.setBuilder(standardBuilder);
        Computer standardComputer = salesman.constructComputer();
        System.out.println(standardComputer);
    }
}

6.2 Golang实现

上述例子用golang实现示例如下：

package main

import "fmt"

// 创建产品类：电脑
type Computer struct {
    CPU     string
    Memory  string
    Storage string
}

// 创建抽象建造者接口
type ComputerBuilder interface {
    SetCPU()
    SetMemory()
    SetStorage()
    GetComputer() *Computer
}

// 创建具体建造者类：高性能电脑建造者
type HighPerformanceComputerBuilder struct {
    computer *Computer
}

func (h *HighPerformanceComputerBuilder) SetCPU() {
    h.computer.CPU = "High-Performance Intel i7"
}

func (h *HighPerformanceComputerBuilder) SetMemory() {
    h.computer.Memory = "16GB Corsair"
}

func (h *HighPerformanceComputerBuilder) SetStorage() {
    h.computer.Storage = "1TB SSD Samsung"
}

func (h *HighPerformanceComputerBuilder) GetComputer() *Computer {
    return h.computer
}

// 创建具体建造者类：普通电脑建造者
type StandardComputerBuilder struct {
    computer *Computer
}

func (s *StandardComputerBuilder) SetCPU() {
    s.computer.CPU = "Standard Intel i3"
}

func (s *StandardComputerBuilder) SetMemory() {
    s.computer.Memory = "8GB Kingston"
}

func (s *StandardComputerBuilder) SetStorage() {
    s.computer.Storage = "256GB SSD Seagate"
}

func (s *StandardComputerBuilder) GetComputer() *Computer {
    return s.computer
}

// 创建指导者类：电脑销售员
type ComputerSalesman struct {
    builder ComputerBuilder
}

func (c *ComputerSalesman) SetBuilder(builder ComputerBuilder) {
    c.builder = builder
}

func (c *ComputerSalesman) ConstructComputer() *Computer {
    c.builder.SetCPU()
    c.builder.SetMemory()
    c.builder.SetStorage()
    return c.builder.GetComputer()
}

func main() {
    salesman := &ComputerSalesman{}

    // 构建高性能电脑
    highPerformanceBuilder := &HighPerformanceComputerBuilder{}
    salesman.SetBuilder(highPerformanceBuilder)
    highPerformanceComputer := salesman.ConstructComputer()
    fmt.Println("High-Performance Computer:")
    fmt.Println("CPU:", highPerformanceComputer.CPU)
    fmt.Println("Memory:", highPerformanceComputer.Memory)
    fmt.Println("Storage:", highPerformanceComputer.Storage)

    // 构建普通电脑
    standardBuilder := &StandardComputerBuilder{}
    salesman.SetBuilder(standardBuilder)
    standardComputer := salesman.ConstructComputer()
    fmt.Println("\nStandard Computer:")
    fmt.Println("CPU:", standardComputer.CPU)
    fmt.Println("Memory:", standardComputer.Memory)
    fmt.Println("Storage:", standardComputer.Storage)
}

6.3 Javascript实现

上述例子用javascript实现示例如下：

// 创建产品类：电脑
class Computer {
    constructor() {
        this.cpu = '';
        this.memory = '';
        this.storage = '';
    }

    toString() {
        return `Computer: CPU=${this.cpu}, Memory=${this.memory}, Storage=${this.storage}`;
    }
}

// 创建抽象建造者类
class ComputerBuilder {
    constructor() {
        this.computer = new Computer();
    }

    setCpu(cpu) {
        this.computer.cpu = cpu;
    }

    setMemory(memory) {
        this.computer.memory = memory;
    }

    setStorage(storage) {
        this.computer.storage = storage;
    }

    getComputer() {
        return this.computer;
    }
}

// 创建具体建造者类：高性能电脑建造者
class HighPerformanceComputerBuilder extends ComputerBuilder {
    setCpu() {
        this.computer.cpu = 'High-Performance Intel i7';
    }

    setMemory() {
        this.computer.memory = '16GB Corsair';
    }

    setStorage() {
        this.computer.storage = '1TB SSD Samsung';
    }
}

// 创建具体建造者类：普通电脑建造者
class StandardComputerBuilder extends ComputerBuilder {
    setCpu() {
        this.computer.cpu = 'Standard Intel i3';
    }

    setMemory() {
        this.computer.memory = '8GB Kingston';
    }

    setStorage() {
        this.computer.storage = '256GB SSD Seagate';
    }
}

// 创建指导者类：电脑销售员
class ComputerSalesman {
    constructor() {
        this.builder = null;
    }

    setBuilder(builder) {
        this.builder = builder;
    }

    constructComputer() {
        this.builder.setCpu();
        this.builder.setMemory();
        this.builder.setStorage();
        return this.builder.getComputer();
    }
}

// 客户端代码
const salesman = new ComputerSalesman();

// 构建高性能电脑
const highPerformanceBuilder = new HighPerformanceComputerBuilder();
salesman.setBuilder(highPerformanceBuilder);
const highPerformanceComputer = salesman.constructComputer();
console.log('High-Performance Computer:');
console.log(highPerformanceComputer.toString());

// 构建普通电脑
const standardBuilder = new StandardComputerBuilder();
salesman.setBuilder(standardBuilder);
const standardComputer = salesman.constructComputer();
console.log('\nStandard Computer:');
console.log(standardComputer.toString());

6.4 C++实现

上述例子用C++实现如下：

#include <iostream>
#include <string>

// 创建产品类：电脑
class Computer {
public:
    std::string cpu;
    std::string memory;
    std::string storage;

    void display() {
        std::cout << "Computer: CPU=" << cpu << ", Memory=" << memory << ", Storage=" << storage << std::endl;
    }
};

// 创建抽象建造者类
class ComputerBuilder {
public:
    virtual void setCpu() = 0;
    virtual void setMemory() = 0;
    virtual void setStorage() = 0;
    virtual Computer* getComputer() = 0;
};

// 创建具体建造者类：高性能电脑建造者
class HighPerformanceComputerBuilder : public ComputerBuilder {
private:
    Computer computer;

public:
    void setCpu() override {
        computer.cpu = "High-Performance Intel i7";
    }

    void setMemory() override {
        computer.memory = "16GB Corsair";
    }

    void setStorage() override {
        computer.storage = "1TB SSD Samsung";
    }

    Computer* getComputer() override {
        return &computer;
    }
};

// 创建具体建造者类：普通电脑建造者
class StandardComputerBuilder : public ComputerBuilder {
private:
    Computer computer;

public:
    void setCpu() override {
        computer.cpu = "Standard Intel i3";
    }

    void setMemory() override {
        computer.memory = "8GB Kingston";
    }

    void setStorage() override {
        computer.storage = "256GB SSD Seagate";
    }

    Computer* getComputer() override {
        return &computer;
    }
};

// 创建指导者类：电脑销售员
class ComputerSalesman {
private:
    ComputerBuilder* builder;

public:
    void setBuilder(ComputerBuilder* builder) {
        this->builder = builder;
    }

    Computer* constructComputer() {
        builder->setCpu();
        builder->setMemory();
        builder->setStorage();
        return builder->getComputer();
    }
};

int main() {
    ComputerSalesman salesman;

    // 构建高性能电脑
    HighPerformanceComputerBuilder highPerformanceBuilder;
    salesman.setBuilder(&highPerformanceBuilder);
    Computer* highPerformanceComputer = salesman.constructComputer();
    std::cout << "High-Performance Computer:" << std::endl;
    highPerformanceComputer->display();

    // 构建普通电脑
    StandardComputerBuilder standardBuilder;
    salesman.setBuilder(&standardBuilder);
    Computer* standardComputer = salesman.constructComputer();
    std::cout << "\nStandard Computer:" << std::endl;
    standardComputer->display();

    return 0;
}

7. 练习题

假设你正在构建一个文本编辑器应用程序。你需要创建一个 Document 类，该类代表文本文档。文档可以包含标题、作者、内容等属性。你需要使用创造者模式来构建文档对象。请完成以下任务：

要求：

  1. 创建 Document 类，该类应包含以下属性：标题（title）、作者（author）、内容（content）。
  2. 创建 DocumentBuilder 抽象类，该类应包含以下纯虚方法：
  • setTitle(title: string)：设置文档的标题。
  • setAuthor(author: string)：设置文档的作者。
  • setContent(content: string)：设置文档的内容。
  • build(): Document：构建并返回文档对象。
  1. 创建两个具体的文档建造者类，一个用于创建普通文档，另一个用于创建重要文档。这两个具体建造者类应继承自 DocumentBuilder 并实现其中的方法：
  • OrdinaryDocumentBuilder：用于创建普通文档，不设置特殊属性。
  • ImportantDocumentBuilder：用于创建重要文档，设置标题为 “Important Document”。
  1. 创建一个 DocumentDirector 类，该类应包含一个建造者对象，并提供一个方法 construct()，该方法调用建造者的方法来构建文档对象。在 construct() 方法中，设置文档的标题、作者和内容。
  2. 在客户端代码中，创建一个 DocumentDirector 对象，并使用普通文档建造者和重要文档建造者来构建两个不同的文档。然后，打印出这两个文档的属性。

示例输出：

Ordinary Document:
Title: My Document
Author: John Doe
Content: This is a regular document.

Important Document:
Title: Important Document
Author: Jane Smith
Content: This is an important document.

你可以在评论区里或者私信我回复您的答案，这样我或者大家都能帮你解答，期待着你的回复~

guohuang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
设计模式【1】——建造者模式
Masli的博客
04-09 1532
建造者模式
设计模式——建造者模式
水寒
08-15 2743
什么是建造者模式 Builder模式也叫建造者模式或者生成器模式，是由GoF提出的23种设计模式中的一种。Builder模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。 首先我们建立一个House对象 package com.meritit; /** * 房子 * @author 李小强
Java设计模式——建造者模式
最新发布
2302_77758423的博客
06-03 1156
建造者模式是一种强大的工具，可以帮助我们更好地组织和管理复杂对象的创建过程。通过将对象的构建过程与其表示分离，我们可以更灵活地控制对象的创建，并提高代码的可读性和可维护性。
Python设计模式——建造者模式
钟灵毓秀的博客
10-26 657
建造者模式是将一个复杂对象的`构造`与`表示`分离，同样的构建过程可以创建不同的东西。
《java设计模式》课后习题模拟试题解答——刘伟.zip
12-26
本资料“《java设计模式》课后习题模拟试题解答——刘伟.zip”主要涵盖了Java设计模式的学习与应用，特别是针对刘伟教授的相关课程的课后习题及模拟试题的解答。 设计模式分为三大类：创建型、结构型和行为型模式。...
JavaScript设计模式之建造者模式介绍
10-25
主要介绍了JavaScript设计模式之建造者模式介绍,将一个复杂对象的构造与它的表示相分离,使同样的创建过程可有不同的表示,这就叫做建造者模式,需要的朋友可以参考下
C++设计模式之建造者模式
01-20
建造者模式 在GOF的《设计模式 可复用面向对象软件的基础》中是这样说的：将一个复杂对象的构建与它的表示分离，使得同样的...在《大话设计模式》一书中，例举了一个很好的例子————建造小人。建造一个小人，要分为
Python设计模式之建造者模式实例详解
12-25
本文实例讲述了Python设计模式之...设计模式——建造者模式 建造者模式(Builder):将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以常见不同的表示 特性: 指挥者(Director) 指挥 建造者(Builder) 建造 Produ
设计模式——刘伟
03-15
7. **建造者模式**：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。适用于构建步骤复杂的对象，例如构造房屋、汽车等。 8. **桥接模式**：将抽象部分与它的实现部分分离，使它们都可以...
【设计模式】- 生成器模式(Builder)（csdn）————程序.pdf
12-04
生成器模式，也称为建造者模式，是一种设计模式，用于创建复杂对象，它允许你按照一系列步骤来构造对象，而这些步骤可以通过不同的实现来产生不同形式的对象。生成器模式的核心在于分离了对象的构造过程和表示细节，...
设计模式之美——教你写出高质量代码
04-10
1. 创建型模式：包括单例模式、工厂方法模式、抽象工厂模式、建造者模式和原型模式。这些模式主要关注对象的创建过程，使得对象的实例化过程更加灵活，同时能够控制类的实例数量。 2. 结构型模式：如适配器模式、...
设计模式.docx
03-08
本文将深入探讨设计模式的基本概念，并详细介绍三种主要的设计模式分类——创建型模式、结构型模式以及行为型模式。 ### 创建型模式 创建型模式主要用于对象的创建过程，旨在通过不同的方式控制对象的创建过程，...
设计模式源码.zip
09-01
最后，"设计模式——基于C#的工程化实现及扩展_示例说明.txt"文件提供了对源码的解释和应用场景的描述，这对于初学者来说是极其宝贵的资源。它可以帮助你理解每个模式的意图、适用场景以及如何在C#代码中正确地引入...
吉林大学软件设计模式课件以及作业答案.zip
09-01
《软件设计模式——深入解析与应用》 软件设计模式，是软件工程中的一种最佳实践，是针对特定问题的解决策略，被广泛应用于软件开发中，以提高代码的可读性、可维护性和可复用性。吉林大学的这门课程通过实例代码、...
python 建造者模式（示例）
11-24
设计模式——建造者模式建造者模式(Builder):将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示特性: 指挥者(Director) 指挥 建造者(Builder) 建造 Product建造者模式是在创建复杂对象的...
软件设计（设计模式）课程实验报告.docx
12-29
创建型设计模式关注对象的创建，包括单例模式、工厂模式、抽象工厂模式、建造者模式和原型模式。实验一和实验二分别深入探讨了这些模式的实现与应用场景。实验不仅要求实现模式，还要求分析其优缺点，以及在特定场景...
Java 设计模式-建造者模式（Builder）Android讲解
05-12
总结来说，Java的设计模式——建造者模式在Android开发中扮演着重要角色，它帮助我们构造复杂对象，提供了一种模块化、易扩展的代码结构，提高了代码的可读性和可维护性。通过理解并熟练运用建造者模式，开发者可以...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

guohuang

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值