Builder Pattern

Are you excited to continue your journey in learning creational design patterns? In the previous lessons, we discussed patterns that allow you to create different types of objects via a common interface. Now, let's dive into the Builder Pattern. The Builder Pattern is another important creational design pattern that helps you construct complex objects, step-by-step, in a readable and manageable way.

In this lesson, you'll learn how to implement the Builder Pattern to construct complex objects using a clear and systematic approach. Specifically, you will explore:

• The need for the Builder Pattern and its benefits.
• How to use a builder to set both required and optional properties of an object.
• Implementing the Builder Pattern in a real-world example by constructing a House class.

You'll see how the Builder Pattern simplifies the creation of complex objects. For instance, using a builder, you can create a House object with different configurations — such as the number of rooms, bathrooms, and optional features like a garage, swimming pool, or garden — in a clean and concise manner.

The Builder Pattern is a creational design pattern that allows you to construct complex objects in a step-by-step manner. Unlike other creational patterns, which support the creation of objects in a single step, the Builder Pattern provides a systematic approach to setting up various properties of an object. This is particularly useful when an object requires numerous configurations or parameters, making the constructor alone insufficient or cumbersome. By using a separate Builder class, the pattern encapsulates the construction logic, providing clarity and flexibility in object creation.

To get a practical understanding of how the Builder Pattern works, let's consider an example of constructing a House class. This House can have various properties such as the number of rooms, bathrooms, a garage, a swimming pool, and a garden. We will use the Builder Pattern to systematically set these properties, making the object creation process clean and understandable.

Here we define the House class with various properties.

public class House {
    private int rooms;
    private int bathrooms;
    private boolean hasGarage;
    private boolean hasSwimmingPool;
    private boolean hasGarden;

    // Private constructor to enforce object creation through Builder
    private House(HouseBuilder builder) {
        this.rooms = builder.rooms;
        this.bathrooms = builder.bathrooms;
        this.hasGarage = builder.hasGarage;
        this.hasSwimmingPool = builder.hasSwimmingPool;
        this.hasGarden = builder.hasGarden;
    }

    // Getters (optional)
    public int getRooms() {
        return rooms;
    }

    public int getBathrooms() {
        return bathrooms;
    }

    public boolean hasGarage() {
        return hasGarage;
    }

    public boolean hasSwimmingPool() {
        return hasSwimmingPool;
    }

    public boolean hasGarden() {
        return hasGarden;
    }
}

This class contains private fields and a private constructor. Notice how the constructor takes a HouseBuilder object as a parameter. This is crucial for the Builder Pattern because it allows the House class to be constructed only through the build() method (implemented below), ensuring an organized and controlled object creation process.