Mastering the Builder Pattern: From Theory to Real Java Code

Preface

Design patterns are typically divided into three categories: creational, structural, and behavioral. This article focuses on the creational Builder pattern, covering its usage scenarios, advantages and disadvantages, components, a practical example, and its usage in the JDK.

Builder Pattern Overview

The Builder pattern (also called Builder or Generator) separates the construction of a complex object from its representation, allowing the same construction process to create different representations.

In simple terms, it breaks a complex object into multiple simple parts and assembles them step by step. The product’s structure stays constant while each part can be configured flexibly.

Think of assembling a computer: components such as CPU, motherboard, memory, storage, graphics card, case, monitor, keyboard, and mouse are fixed, but their specific models can vary based on budget and use case.

Structure and Roles

The Builder pattern typically involves four roles:

Product : the complex object being built, composed of multiple parts.

Builder (abstract) : an interface or abstract class declaring methods for creating each part and a method to retrieve the final product.

Concrete Builder : implements the Builder interface, providing specific configurations for each part.

Director : orchestrates the building process by invoking the Builder’s methods in a defined order, isolating the client from construction details.

Implementation Example

We model a configurable computer consisting of a laptop, mouse, screen, and keyboard.

public class Computer {
    private Laptop laptop;
    private Mouse mouse;
    private Screen screen;
    private Keyboard keyboard;
    public void show() {
        System.out.println("笔记本配置：" + laptop.getName());
        System.out.println("鼠标配置：" + mouse.getName());
        System.out.println("显示器配置：" + screen.getName());
        System.out.println("键盘配置：" + keyboard.getName());
    }
    // getters and setters omitted
}

The abstract builder defines the construction steps:

public interface ComputerBuilder {
    void constructLaptop();
    void constructMouse();
    void constructScreen();
    void constructKeyboard();
    Computer getResult();
}

Two concrete builders illustrate a common configuration and a high‑end configuration.

public class CommonComputerBuilder implements ComputerBuilder {
    private Computer computer = new Computer();
    @Override public void constructLaptop() { computer.setLaptop(new Laptop("A", "华为笔记本")); }
    @Override public void constructMouse() { computer.setMouse(new Mouse("A", "无线鼠标")); }
    @Override public void constructScreen() { computer.setScreen(new Screen("A", "液晶显示器")); }
    @Override public void constructKeyboard() { computer.setKeyboard(new Keyboard("A", "普通键盘")); }
    @Override public Computer getResult() { return computer; }
}

public class SupperComputerBuilder implements ComputerBuilder {
    private Computer computer = new Computer();
    @Override public void constructLaptop() { computer.setLaptop(new Laptop("S", "Mac Boor Pro")); }
    @Override public void constructMouse() { computer.setMouse(new Mouse("A", "无线鼠标")); }
    @Override public void constructScreen() { computer.setScreen(new Screen("S", "液晶曲面屏")); }
    @Override public void constructKeyboard() { computer.setKeyboard(new Keyboard("S", "机械键盘")); }
    @Override public Computer getResult() { return computer; }
}

The Director coordinates the building process:

public class Director {
    private ComputerBuilder builder;
    public Director(ComputerBuilder builder) { this.builder = builder; }
    public Computer construct() {
        builder.constructLaptop();
        builder.constructMouse();
        builder.constructScreen();
        builder.constructKeyboard();
        return builder.getResult();
    }
}

Client code demonstrates assembling both configurations:

public class Client {
    public static void main(String[] args) {
        ComputerBuilder builder = new CommonComputerBuilder();
        Director director = new Director(builder);
        Computer product = director.construct();
        product.show();
        System.out.println("------------------");
        builder = new SupperComputerBuilder();
        director = new Director(builder);
        product = director.construct();
        product.show();
    }
}

Running the program prints the component details for each configuration, illustrating how adding a new builder class enables new product variants without modifying existing code, adhering to the Open/Closed principle.

Application Scenarios

The Builder pattern is ideal when:

The object to create is complex and composed of many parts that may vary independently, but the construction sequence is stable.

The product class has many optional parameters or requires step‑by‑step construction.

Various product variants share a similar construction process with only minor differences.

Construction involves a large number of parameters, making telescoping constructors unwieldy.

Pros and Cons

Advantages

Concrete builders are independent, making it easy to replace or add new builders, enhancing extensibility.

Encapsulation separates construction from representation; clients need not know internal details.

Fine‑grained control over the creation process without affecting other modules.

Disadvantages

Requires additional Builder interfaces and concrete classes, increasing code size.

If product variations become too complex, many concrete builders may be needed, leading to a bulky system.

Changes to the product’s internal structure often require corresponding changes in builders, raising maintenance effort.

When product variants differ greatly, the pattern’s shared structure may not be suitable.

If only a single product variant is needed, the abstract builder and director can be omitted.

Builder vs. Factory

While both patterns deal with object creation, they focus on different concerns:

Builder emphasizes the step‑by‑step assembly order; Factory focuses on creating objects.

Builder constructs complex objects with many parts; Factory typically creates simple, fully‑initialized objects.

Builder reveals the internal composition of the product; Factory hides it.

Different construction sequences in Builder can lead to different final products.

Builder in the JDK

The widely used StringBuilder class demonstrates the Builder pattern. Its append methods return this, allowing chained calls that progressively build the final string.

public AbstractStringBuilder append(String str) {
    if (str == null) return appendNull();
    int len = str.length();
    ensureCapacityInternal(count + len);
    str.getChars(0, len, value, count);
    count += len;
    return this;
}
@Override
public StringBuilder append(char c) {
    super.append(c);
    return this;
}

Conclusion

This article walked through the Builder pattern, explaining its components, Java implementation, typical use cases, strengths and weaknesses, and how it differs from the Factory pattern. Understanding these fundamentals helps developers choose the right pattern for complex object creation and adapt it to real‑world projects.