【设计模式系列笔记】建造者模式

本文涉及的产品
RDS SQL Server Serverless,2-4RCU 50GB 3个月
推荐场景:
RDS MySQL Serverless 基础系列,0.5-2RCU 50GB
云数据库 RDS SQL Server,基础系列 2核4GB
简介: 建造者模式是一种创建型设计模式,用于将复杂对象的构建与其表示分离,使构建过程可定制。关键元素包括产品类(定义要构建的对象)、建造者接口(定义构建方法)、具体建造者类(实现构建过程)和指导者类(负责构建过程)。通过建造者模式,客户端可以灵活地创建具有不同表示的复杂对象,提高代码的可读性和可维护性,尤其适用于构建过程复杂且包含多个可选部分的情况。

1、建造者模式介绍

建造者模式(Builder Pattern)是一种创建型设计模式。当我们需要创建一个包含多个组成部分的复杂对象时,直接使用构造函数进行初始化可能会导致构造函数参数的过度增加,可读性和维护性降低。

建造者模式的目的是将一个复杂对象的构建过程与其具体表示分离,使得同样的构建过程可以创建不同的表示。在Java中,建造者模式通常通过一个建造者接口和一个具体的建造者类来实现。

2、关键思想

建造者模式的关键思想是将一个复杂对象的构建过程与其具体表示分离,使得同样的构建过程可以创建不同的表示。这通过以下几个关键元素来实现:

  1. 产品类(Product): 表示要构建的复杂对象。它包含了多个组成部分,这些部分的组合形成了完整的对象。产品类通常有一些setter方法用于设置各个部分的值。
  2. 建造者接口(Builder): 定义了构建复杂对象的方法。这些方法对应了产品的各个组成部分,用于设置它们的值。通过建造者接口,客户端可以指导构建过程,逐步地创建产品。
  3. 具体的建造者类(ConcreteBuilder): 实现了建造者接口,负责实际构建产品的各个部分。每个具体的建造者类都可以以不同的方式构建对象的各个部分,因此通过选择不同的具体建造者,可以创建具有不同表示的对象。
  4. 指导者类(Director): 负责使用建造者接口的方法按照一定的顺序构建产品。它隐藏了产品的具体构建过程,客户端通过指导者来完成产品的构建。
  5. 客户端(Client): 创建一个具体的建造者对象,并将其传递给指导者。通过指导者的构建方法,客户端可以控制构建过程的顺序和方式,最终获取构建完成的产品。

通过这种方式,建造者模式允许客户端以一种更加灵活的方式构建复杂对象,而不需要直接调用其构造函数或者在构造函数中传递大量参数。这提高了代码的可读性、可维护性,并允许在不同的情境中构建不同表示的对象。建造者模式尤其适用于需要构建对象的构建过程比较复杂,包含多个可选部分的情况。

3、实现方式

我们可以以构建一台计算机为例子。一台计算机包含了多个组成部分,例如CPU、内存、硬盘等,而且用户可以选择不同的配置。下面是Java代码的具体实现:

示例代码

// 1. 产品类(Computer):表示要构建的复杂对象,计算机。
public class Computer {
    private String cpu;
    private String memory;
    private String hardDisk;
    private String graphicsCard;
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }
    public void setMemory(String memory) {
        this.memory = memory;
    }
    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }
    public void setGraphicsCard(String graphicsCard) {
        this.graphicsCard = graphicsCard;
    }
    // other parts and getters...
}
/**
 * 建造者接口(ComputerBuilder):
 * 定义了构建复杂对象的方法,包括设置计算机的各个部分。
 */
public interface ComputerBuilder {
    /**
     * 构建CPU部分。
     * @param cpu CPU型号
     */
    void buildCPU(String cpu);
    /**
     * 构建内存部分。
     * @param memory 内存容量
     */
    void buildMemory(String memory);
    /**
     * 构建硬盘部分。
     * @param hardDisk 硬盘容量
     */
    void buildHardDisk(String hardDisk);
    /**
     * 构建显卡部分。
     * @param graphicsCard 显卡型号
     */
    void buildGraphicsCard(String graphicsCard);
    /**
     * 获取构建完成的计算机对象。
     * @return 构建完成的计算机对象
     */
    Computer getResult();
}
// 3. 具体的建造者类(StandardComputerBuilder):具体的建造者类实现了建造者接口,
//    负责实际构建计算机的各个部分,并提供获取最终产品的方法。
public class StandardComputerBuilder implements ComputerBuilder {
    private Computer computer = new Computer();
    @Override
    public void buildCPU(String cpu) {
        computer.setCpu(cpu);
    }
    @Override
    public void buildMemory(String memory) {
        computer.setMemory(memory);
    }
    @Override
    public void buildHardDisk(String hardDisk) {
        computer.setHardDisk(hardDisk);
    }
    @Override
    public void buildGraphicsCard(String graphicsCard) {
        computer.setGraphicsCard(graphicsCard);
    }
    @Override
    public Computer getResult() {
        return computer;
    }
}
// 4. 指导者类(ComputerDirector):指导者类负责使用建造者接口的方法按照一定的顺序构建计算机。
//    指导者隐藏了计算机的具体构建过程。
public class ComputerDirector {
    public void construct(ComputerBuilder builder, String cpu, String memory,
                          String hardDisk, String graphicsCard) {
        builder.buildCPU(cpu);
        builder.buildMemory(memory);
        builder.buildHardDisk(hardDisk);
        builder.buildGraphicsCard(graphicsCard);
    }
}
// 5. 客户端使用建造者模式:客户端通过创建一个具体的建造者对象,并将其传递给指导者类,
//    通过指导者的构建方法来构建计算机。
public class Client {
    public static void main(String[] args) {
        // 创建具体的建造者对象
        ComputerBuilder builder = new StandardComputerBuilder();
        // 创建指导者对象
        ComputerDirector director = new ComputerDirector();
        // 使用指导者构建计算机,传递所需的配置
        director.construct(builder, "Intel i7", "16GB RAM", "1TB SSD", "NVIDIA RTX 3080");
        // 获取构建完成的计算机对象
        Computer computer = builder.getResult();
        // Now, the computer is constructed with the specified components.
    }
}

这个例子演示了如何使用建造者模式来创建一个复杂对象,使得客户端能够根据自己的需求选择不同的配置,而不需要关心构建过程的具体实现。这提高了代码的灵活性和可维护性。

要点:

  1. 分离构建过程和表示: 建造者模式将一个对象的构建过程与最终表示分离,使得客户端可以根据需要选择不同的表示,而不必关心构建的细节。
  2. 逐步构建: 建造者模式通常提供一系列的构建方法,客户端可以按照一定的顺序逐步调用这些方法来构建对象,最终获得构建完成的对象。
  3. 指导者角色: 在一些情况下,可以使用指导者(Director)类来封装构建过程,使得客户端更加简洁,只需指导指导者构建对象即可。
  4. 灵活性: 建造者模式允许客户端根据需要选择不同的具体建造者,从而构建不同的表示。这提高了灵活性,特别适用于构建过程复杂、有多个可选部分的对象。

注意事项:

  1. 适用场景: 建造者模式适用于构建过程比较复杂、有多个可选部分的对象。如果对象的构建过程简单,或者对象只有一个表示,可能没有必要使用建造者模式。
  2. 构建方法必须相同: 建造者接口中定义的构建方法必须是相同的,这样在切换具体建造者时客户端不会受到影响。
  3. 不同的建造者可以构建不同的表示: 不同的具体建造者可以实现相同的接口,但是它们的实现可以有所不同,从而构建不同表示的对象。
  4. 指导者的使用: 指导者角色不是必需的,有些情况下客户端可以直接与具体建造者交互,按照自己的需要构建对象。
  5. 构建过程不一定是逐步的: 虽然建造者模式通常是逐步构建的,但在某些情况下,也可以一次性构建完成整个对象。这取决于具体的需求。

总体来说,建造者模式提供了一种灵活、清晰的对象构建方式,特别适用于构建过程复杂、有多个可选部分的场景。在选择使用建造者模式时,需要根据具体情况权衡其优势和不足。

优点:

  1. 分离构建过程和表示: 建造者模式将一个复杂对象的构建过程与其表示分离,使得同样的构建过程可以创建不同的表示。这提高了灵活性,允许构建过程的变化不影响最终对象的表示。
  2. 逐步构建: 建造者模式通常提供一系列的构建方法,客户端可以按照一定的顺序逐步调用这些方法来构建对象。这种逐步构建的方式使得构建过程更加清晰、可控。
  3. 易于扩展: 当需要添加新的部分或者改变构建过程时,可以通过实现新的具体建造者来扩展系统,而不需要修改已有的代码。
  4. 更好的可读性: 使用建造者模式构建对象时,客户端代码更加清晰,不再需要直接调用构造函数或者在构造函数中传递大量参数。
  5. 可以创建不同表示的对象: 不同的具体建造者可以构建不同表示的对象,满足不同客户端的需求。

缺点:

  1. 类的个数增加: 引入建造者模式会增加系统中类的个数,特别是在有多个表示的情况下,可能会导致类的数量呈指数级增长。
  2. 构建过程复杂: 对于简单对象的构建,引入建造者模式可能会使得构建过程变得过于复杂,不切实际。

应用场景:

  1. 需要构建复杂对象: 建造者模式适用于构建过程复杂、有多个可选部分的对象,特别是对象的构建步骤比较多、步骤顺序灵活变化的情况。
  2. 需要创建不同表示的对象: 当需要创建多种不同表示的对象时,可以使用建造者模式,每个具体建造者对应一种表示。
  3. 构建过程中存在可选部分: 如果构建过程中存在一些可选的部分,而客户端需要根据需求选择性地构建这些部分,建造者模式提供了灵活的解决方案。
  4. 对象的构建过程稳定,但表示不同时: 如果对象的构建过程相对稳定,但需要根据不同的需求创建不同的表示,建造者模式是一个很好的选择。

总的来说,建造者模式在构建过程比较复杂、有多个可选部分、需要创建不同表示的对象时发挥着重要作用。在具体应用时,需要根据系统的需求和设计目标权衡其优缺点

目录
相关文章
|
2天前
|
设计模式 Java API
Kotlin教程笔记(50) - 改良设计模式 - 工厂模式
Kotlin教程笔记(50) - 改良设计模式 - 工厂模式
|
2天前
|
设计模式 监控 Java
Kotlin教程笔记(52) - 改良设计模式 - 观察者模式
Kotlin教程笔记(52) - 改良设计模式 - 观察者模式
|
2天前
|
设计模式 安全 Java
Kotlin教程笔记(51) - 改良设计模式 - 构建者模式
Kotlin教程笔记(51) - 改良设计模式 - 构建者模式
|
16天前
|
设计模式 安全 Java
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
27 2
|
9天前
|
设计模式 监控 Java
Kotlin教程笔记(52) - 改良设计模式 - 观察者模式
Kotlin教程笔记(52) - 改良设计模式 - 观察者模式
27 9
|
8天前
|
设计模式 监控 Java
Kotlin教程笔记(52) - 改良设计模式 - 观察者模式
Kotlin教程笔记(52) - 改良设计模式 - 观察者模式
21 2
|
18天前
|
设计模式 Java 开发者
Kotlin教程笔记(54) - 改良设计模式 - 迭代器模式
本教程详细讲解Kotlin语法,适合希望深入了解Kotlin的开发者。对于快速学习Kotlin的用户,推荐查看“简洁”系列教程。本文重点介绍迭代器模式,通过具体示例展示了如何在Kotlin中实现迭代器模式,包括使用Iterator、Iterable接口及重载iterator运算符的方法。
27 4
|
18天前
|
设计模式 算法 Kotlin
Kotlin教程笔记(53) - 改良设计模式 - 策略模式
本教程详细讲解Kotlin语法,适合深入学习。快速入门可参考“简洁”系列教程。本文通过游泳运动员的案例,介绍策略模式及其在Kotlin中的改良应用,利用高阶函数简化代码结构,提高灵活性。
27 3
|
19天前
|
设计模式 Java 开发者
Kotlin教程笔记(54) - 改良设计模式 - 迭代器模式
本教程详细讲解了Kotlin中的迭代器模式,包括如何通过实现Iterator和Iterable接口以及重载iterator运算符来实现可遍历的自定义集合。示例展示了如何创建一个图书集类,并通过不同方式使其支持遍历操作,适合希望深入了解Kotlin迭代器模式的开发者。
29 3
|
19天前
|
设计模式 监控 Java
Kotlin教程笔记(52) - 改良设计模式 - 观察者模式
本教程详细讲解Kotlin语法,适合深入学习。对于快速掌握Kotlin,推荐“简洁”系列教程。本文特别介绍了观察者模式,包括使用Java API和Kotlin委托属性(如Delegates.observable)实现的方法,旨在帮助开发者更高效地实现和优化观察者模式的应用。
30 3