Builder Design Pattern in Java: Comprehensive Guide

In this complete guide on Builder Design Pattern in Java, we will do in-depth exploration of different aspects of Builder Design pattern in Java. So, let’s get started.

Table of Contents

What is Builder Design Pattern in Java ?

Builder Design Pattern in Java is Creational Design pattern used for building a complex Object step by step and then finally return the built Object.

It basically separates the construction of Object from it’s representation, so that the same construction process can result in different representations.

When to use Builder Design Pattern in Java

In java, we use constructors to create an Object by taking a bunch of parameters for creating the Object.Our problem starts when an Object can be created with lot of parameters, some of them may be mandatory and others may be optional.

We have the following options to fix the problem.

1. Using overloaded constructors

We can create different constructors that can take different parameters.

Problems:Too many constructors-ugly code,hard to maintain.

2. Using no-args constructor and setters

Use no-args constructor and then provide setters to set the parameters.

Problems:

The object may be in inconsistent state during building.We should build the Object completely before returning it to the Client class.
Also it makes the Object mutable by exposing the setters.

Solution : Use Builder Pattern. It helps to create immutable objects.

Instead of directly creating the required Object, Client class creates the Builder object with the mandatory parameters and then sets other optional parameters in the Builder object.Finally, Builder’s build method is called to return the actual required Object with all the set parameters.

We will take a simple example of Cake for understanding the Builder Pattern. Here we will use the CakeBuilder to prepare the cake in steps and then finally return the Cake Object for consumption.

Class Diagram: Builder Design Pattern in Java

Code: Builder Design Pattern in Java

public class Cake {
    private final double milk;
    private final double sugar;
    private final double butter;
    private final int eggs;
    private final double bakingpowder;
    private final int vanila;
    private final int chocolate;
    private final double flour;
    // constructor should be private to enforce object creation through builder
    private Cake(CakeBuilder builder) {
        this.milk = builder.milk;
        this.sugar = builder.sugar;
        this.butter = builder.butter;
        this.eggs = builder.eggs;
        this.bakingpowder = builder.bakingpowder;
        this.vanila = builder.vanila;
        this.flour = builder.flour;
        this.chocolate = builder.chocolate;
    }
    public static class CakeBuilder {
        private double milk; //cup
        private double sugar; //cup
        private double butter; //cup
        private int eggs;
        private double bakingpowder; //spoon
        private int vanila; //spoon
        private double flour; //cup
        private int chocolate; //spoon
        //Cake builder constructor with mandatory ingredients for cake so that we do not create an incomplete cake.
        public CakeBuilder(double flour, double milk, double sugar, double bakingpowder, double butter) {
            this.flour = flour;
            this.milk = milk;
            this.sugar = sugar;
            this.bakingpowder = bakingpowder;
            this.butter = butter;
        }
        public CakeBuilder eggs(int number) {
            this.eggs = number;
            return this;
        }
        public CakeBuilder vanila(int spoon) {
            this.vanila = spoon;
            return this;
        }
        public CakeBuilder chocolate(int spoon) {
            this.chocolate = spoon;
            return this;
        }
        // return fully build object
        public Cake build() {
            return new Cake(this);
        }
    }
    @Override
    public String toString() {
        return "Cake { milk=" + milk + ", sugar=" + sugar + ", butter=" + butter +
            ", eggs=" + eggs + ", vanila=" + vanila + ", chocolate=" + chocolate + ", bakingpowder=" +
            bakingpowder + ", flour=" + flour + '}';
    }

}


public class CakeConsumer {

    public static void main(String[] args) {

        Cake simpleEggLessCake = new Cake.CakeBuilder(1.5, 0.5, 1, 0.5, 1)
            .build();
        System.out.println("simpleEggLessCake:" + simpleEggLessCake);
        Cake simpleEggCake = new Cake.CakeBuilder(1.5, 0.5, 1, 0.5, 1).eggs(3)
            .build();

        System.out.println("simpleEggCake:" + simpleEggCake);
        Cake vanillaEggCake = new Cake.CakeBuilder(1.5, 0.5, 1, 0.5, 1).eggs(3).vanila(2)
            .build();
        System.out.println("vanillaEggCake:" + vanillaEggCake);
    }
}

Output

simpleEggLessCake:Cake { milk=0.5, sugar=1.0, butter=1.0, eggs=0, vanila=0, chocolate=0, bakingpowder=0.5, flour=1.5}
simpleEggCake:Cake { milk=0.5, sugar=1.0, butter=1.0, eggs=3, vanila=0, chocolate=0, bakingpowder=0.5, flour=1.5}
vanillaEggCake:Cake { milk=0.5, sugar=1.0, butter=1.0, eggs=3, vanila=2, chocolate=0, bakingpowder=0.5, flour=1.5}

Pros of Builder Design Pattern in Java

The Builder Design Pattern in Java offers several advantages that make it a valuable choice for constructing complex objects in a flexible and readable manner. Here are some of the pros of using the Builder Design Pattern:

Readable and Intuitive Code: The Builder Pattern enhances code readability by providing descriptive methods for setting object attributes. This results in code that reads like a series of method calls, making it easy to understand the sequence of operations.
Flexible Object Construction: The pattern allows you to create objects step by step, setting only the necessary attributes at each stage. This flexibility is particularly useful when dealing with objects with numerous optional parameters.
Eliminates Telescoping Constructors: The Builder Pattern eliminates the need for telescoping constructors, which occur when constructors have a large number of parameters or various combinations. Instead of creating multiple constructors, you use the builder to set attributes in a clear and modular way.
Prevents Object Inconsistencies: The pattern ensures that an object is fully constructed and consistent before it’s returned. This prevents the object from being in an incomplete or invalid state, which can happen when using setters directly.
Encourages Method Chaining: The pattern often involves method chaining, where each method returns the builder instance itself. This allows you to chain multiple attribute-setting calls together, improving the code’s flow and conciseness.
Separation of Concerns: The Builder Pattern separates the construction logic from the object’s main implementation. This separation of concerns enhances maintainability and makes it easier to modify the construction process without affecting the object’s structure.
Eases Testing: Builders can be designed to produce test-specific objects with controlled attributes, making it easier to write unit tests for different scenarios without complex object setup.
Immutable Objects: The Builder Pattern can be used to create immutable objects, ensuring that once an object is constructed, its attributes cannot be modified. This is valuable for ensuring data integrity and preventing unintended changes.
Enhanced API Design: When designing an API, the Builder Pattern can provide a user-friendly way to create objects with a clear and fluent syntax. This can result in an intuitive and well-documented API for other developers to use.
Reduced Dependency on Constructors: By using the builder, you reduce the reliance on constructors with numerous parameters. This can help prevent confusion over parameter order and types.
Clear Object Initialization: Since the builder requires explicit attribute setting, it’s easier to understand how an object is initialized. This transparency can be especially helpful when working with large and complex objects.

Cons of Builder Design Pattern in Java

The Builder Design Pattern in Java is a powerful tool for constructing complex objects with ease and flexibility. However, like any design pattern, it has its limitations and potential drawbacks. Here are some cons of using the Builder Design Pattern in Java:

Increased Code Complexity: While the Builder Pattern simplifies object construction by breaking it down into separate steps, it can also introduce additional classes and methods, leading to increased code complexity. This complexity might be unnecessary for simple object creation scenarios.
Boilerplate Code: Implementing the builder classes and methods can result in boilerplate code, especially when dealing with multiple attributes or properties. This can make the codebase harder to read and maintain.
Memory Overhead: The Builder Pattern involves the creation of additional objects (builder objects) to assemble the final object. This can lead to a slight increase in memory overhead, which might be negligible for most applications but can still be a concern in resource-constrained environments.
Less Compact Syntax: While the Builder Pattern provides a structured way to set attributes and construct objects, it may not be as concise as using a single constructor with named or optional parameters, particularly in languages with powerful features like named arguments.
Dependency on Separate Classes: Introducing separate builder classes means your codebase becomes dependent on those classes. If changes are made to the builder classes or interfaces, it might require adjustments in other parts of the codebase as well.
Overhead for Simple Objects: The Builder Pattern’s benefits shine when dealing with complex objects with many optional parameters. For simple objects, the added complexity of using a builder might outweigh the benefits, making direct instantiation or other creational patterns more suitable.
Learning Curve: Developers who are not familiar with the Builder Pattern might need some time to understand its concepts and implementation. This could potentially slow down the development process, especially in teams where the pattern is not commonly used.
Increased Number of Classes: Implementing the Builder Pattern requires creating additional classes for the builder and potentially separate interfaces for the product and builder. This can lead to a larger number of classes in the project, which might be overwhelming for smaller projects.

Builder Pattern vs Factory Pattern

Aspect	Builder Pattern	Factory Pattern
Intent	Used to create complex objects step by step, allowing flexibility and avoiding constructor complexities.	Used to create objects by delegating the creation logic to a separate factory method.
Complexity	Handles complex object creation and configuration.	Generally simpler than the Builder Pattern.
Usage Scenario	Suitable when dealing with objects with multiple optional parameters.	Suitable when you need to create objects of a single family or type.
Number of Methods	Involves multiple methods to set various attributes and create the final object.	Involves a single method in the factory to create an object.
Mutability of Objects	Allows modification of object attributes before finalizing the object.	Objects may be immutable after creation.
Complex Configurations	Well-suited for objects with many optional parameters and various configurations.	Better for creating objects with simpler configurations.
Examples	Java’s `StringBuilder`, various GUI component builders.	Java’s `Calendar` (using `getInstance`), `java.sql.DriverManager`.

Applications of Builder Design Pattern in Java

The Builder Design Pattern in Java finds its applications in various scenarios where you need to construct complex objects with multiple attributes, and you want to ensure a flexible, readable, and maintainable approach to object creation. Here are some common applications of the Builder Design Pattern in Java:

Creating Immutable Objects: Builders can be used to create immutable objects where all attributes are set during object construction, and they cannot be modified afterward. This is valuable for ensuring data integrity and thread safety.
Configuration and Initialization: When initializing objects with a large number of optional parameters or configurations, the Builder Pattern can provide a clean and organized way to set these parameters step by step.
Fluent Interfaces: The Builder Pattern often involves method chaining, which leads to fluent and readable code. This is particularly useful for configuring objects with a clear, natural syntax.
Complex Object Creation: For objects with complex construction requirements or numerous attributes, the Builder Pattern simplifies the construction process by breaking it down into smaller steps.
Variety of Objects: When dealing with a family of related objects that share a common structure but have variations in attributes, the Builder Pattern can help in creating different instances of these objects without duplicating code.
Test Data Generation: In testing scenarios, the Builder Pattern can be used to generate test data with specific attributes for different test cases. This ensures that the generated objects have consistent and controlled characteristics.
Decoupling Object Construction: The Builder Pattern separates the construction logic from the main object implementation, promoting better separation of concerns and making it easier to modify or extend the construction process.
Eliminating Telescoping Constructors: When constructors with multiple parameters lead to confusion or error-prone code, the Builder Pattern replaces them with a more intuitive and readable approach to setting attributes.
Composite Objects: In cases where objects are composed of multiple components, the Builder Pattern can help in constructing and assembling these components into the final object.
Database Query Builders: In database operations, query builders often require constructing complex SQL queries with optional clauses. The Builder Pattern can be applied to construct these queries incrementally.
Document Object Model (DOM) Manipulation: When working with XML or HTML structures, the Builder Pattern can be used to create and manipulate complex hierarchical structures.
Creating Graphic Objects: When creating graphic objects like shapes or diagrams, the Builder Pattern can simplify the process by allowing incremental addition of components and attributes.
Game Development: In game development, the Builder Pattern can be applied to create game characters, items, or levels with varying attributes.
Report Generation: When generating reports with various sections and attributes, the Builder Pattern can help create the report step by step, allowing for dynamic customization.

Best Practices: Builder Design Pattern in Java

Implementing the Builder Design Pattern in Java comes with a set of best practices to ensure clean, maintainable, and efficient code. Here are some best practices to consider when using the Builder Design Pattern:

Clear Separation of Concerns: The main goal of the Builder Pattern is to separate the construction of complex objects from their representation. Ensure that the builder class is solely responsible for constructing the object, while the main class focuses on its core functionality.
Single Responsibility Principle (SRP): Each class should have a single responsibility. The builder class should be responsible only for constructing the object, and the main class should handle its core behavior. Avoid adding unrelated logic to either class.
Use Method Chaining: Implement method chaining in the builder class to provide a fluent and readable API for setting attributes. This allows for concise and intuitive code when configuring object properties.
Immutable Objects: Design the object to be constructed as immutable, where its attributes cannot be modified after construction. This ensures thread safety, data integrity, and predictability.
Use Static Inner Class: Implement the builder as a static inner class of the main class. This keeps the builder closely associated with the main class while also encapsulating its construction logic.
Optional Attributes: If your object has optional attributes, provide methods in the builder to set those attributes. Consider using default values or null checks for attributes that are not set.
Validation: Implement validation checks within the builder to ensure that the object is constructed with valid attributes. This can help prevent errors or inconsistencies.
Complex Initialization Logic: If the object requires complex initialization logic, perform that logic in the builder’s build method. This ensures that the object is fully configured before it is returned.
Avoid Overloading Constructors: Instead of having multiple constructors with different parameter combinations, use the builder pattern to handle various configurations in a clean and organized manner.
Initialize Required Attributes: Ensure that all required attributes are set before calling the build method. If an attribute is not set, throw an exception to indicate incomplete object construction.

Built-in Examples of the Builder Design Pattern in Java

There are several built-in examples of the Builder Design Pattern in Java that are part of the standard libraries or widely used in various frameworks and APIs. Here are a few notable examples:

StringBuilder and StringBuffer: The StringBuilder and StringBuffer classes in Java are examples of the Builder Design Pattern. They allow you to construct strings by appending various parts together using methods like append(). This pattern is efficient for building strings incrementally.
java.util.Calendar: The Calendar class provides a way to create instances representing dates and times. You can’t directly instantiate Calendar using constructors; instead, you use a static factory method getInstance() to get an instance of Calendar with various attributes preconfigured.
java.lang.ProcessBuilder: The ProcessBuilder class is used to create and control processes in Java. It follows the Builder pattern to set up process attributes, environment variables, and command arguments before starting the process using start().
java.util.stream.Stream.Builder: The Stream.Builder interface in the java.util.stream package is used to construct instances of Stream. It provides methods like add() to add elements to the stream incrementally before building the final stream using the build() method.

Conclusion: Builder Design Pattern in Java

In this comprehensive guide on the Builder Design Pattern in Java, we have delved into the various aspects of this pattern, from its definition to its applications and best practices. Let’s recap the key points that we explored throughout the article:

What is Builder Design Pattern in Java: The Builder Design Pattern in Java is used for constructing complex objects step by step while allowing different representations of the same construction process
When to use Builder Design Pattern in Java: The Builder Pattern is suitable when creating objects with multiple optional parameters or configurations.
Class Diagram and Code Example: We provided a detailed example of a CakeBuilder class for creating cake objects.
Pros of Builder Design Pattern in Java: The advantages of using the Builder Design Pattern include readable and intuitive code, flexible object construction, elimination of telescoping constructors, prevention of object inconsistencies, and separation of concerns. It also encourages method chaining and simplifies testing.
Cons of Builder Design Pattern in Java: Some drawbacks of the Builder Pattern include increased code complexity, potential boilerplate code, memory overhead due to additional objects, less compact syntax compared to other approaches, dependency on separate classes, and overhead for simple objects.
Builder Pattern vs Factory Pattern: We highlighted the differences between the Builder Pattern and the Factory Pattern, discussing their intents, complexity, usage scenarios, mutability of objects, and examples of each pattern.
Applications of Builder Design Pattern in Java: The Builder Pattern is applied in scenarios involving the creation of immutable objects, object configuration and initialization, fluent interfaces, complex object creation, generating test data, composite objects, database query builders, and more.
Best Practices for Using Builder Design Pattern in Java: To implement the Builder Pattern effectively, we provided a set of best practices.
Built-in Examples of the Builder Design Pattern in Java: There are several built-in examples of the Builder Design Pattern in Java that are part of the standard libraries or widely used in various frameworks and APIs.

The Builder Design Pattern in Java is a Creational Design pattern that enables the creation of complex objects with ease, flexibility, and maintainability. By following best practices and understanding its strengths and limitations, developers can leverage this pattern to enhance their code organization and object creation processes.

Must Read Articles:

Professional Tips: Top 10 Design Principles in Java 2023

Design Patterns in Java: For Efficient Development 2023