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

    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)

    • 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
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81

    在这个示例中：

    • 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);
    }
}

    • 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
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116

    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)
}

    • 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
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98

    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());

    • 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
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100

    6.4 C++实现

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

    #include 
#include 

// 创建产品类：电脑
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;
}

    • 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
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107

    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.

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

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

  • 相关阅读:
    cuda并行计算编程
    Centos7 yum报错 Could not resolve host: mirrorlist.centos.org
    【多线程】锁策略
    Unity之OpenXR+XR Interaction Toolkit快速监听手柄任意按键事件
    敏捷开发的优势
    spark读写elasticsearch的坑
    ESP8266-Arduino编程实例-MQ-5液化天然气传感器驱动
    python+Vue心理健康网站django
    分享下最近遇到的5种网站变慢的案例
    【C++】C++11------线程库
  • 原文地址：https://blog.csdn.net/guohuang/article/details/133269431