Builder Design Pattern

What is the Builder Design Pattern?

The Builder Design Pattern is a creational design pattern that is used to create complex objects step by step. Instead of creating an object using a long constructor with many parameters, the Builder pattern allows you to build the object in a clear and readable way.

This pattern is very useful when:

• An object has many optional fields
• Constructors become too long and confusing
• You want better readability while creating objects

In simple words, the Builder pattern helps you construct an object gradually and only set the values you need.

Real-Life Example

Think about ordering a burger 🍔. You can choose:

• Bread type
• Cheese
• Vegetables
• Sauces

You don’t need to order all items every time. You just add what you want. This is exactly how the Builder pattern works.

Builder Design Pattern Structure

• Product – The complex object being created
• Builder – Defines steps to build the object
• Concrete Builder – Implements the builder steps
• Director (optional) – Controls the building process

Simple Java Example

Step 1: Create the Product Class

public class Computer {

    private String CPU;
    private String RAM;
    private String storage;
    private boolean graphicsCard;

    private Computer(Builder builder) {
        this.CPU = builder.CPU;
        this.RAM = builder.RAM;
        this.storage = builder.storage;
        this.graphicsCard = builder.graphicsCard;
    }

    public static class Builder {
        private String CPU;
        private String RAM;
        private String storage;
        private boolean graphicsCard;

        public Builder setCPU(String CPU) {
            this.CPU = CPU;
            return this;
        }

        public Builder setRAM(String RAM) {
            this.RAM = RAM;
            return this;
        }

        public Builder setStorage(String storage) {
            this.storage = storage;
            return this;
        }

        public Builder setGraphicsCard(boolean graphicsCard) {
            this.graphicsCard = graphicsCard;
            return this;
        }

        public Computer build() {
            return new Computer(this);
        }
    }
}

Step 2: Use the Builder to Create an Object

public class BuilderPatternDemo {

    public static void main(String[] args) {

        Computer computer = new Computer.Builder()
                .setCPU("Intel i7")
                .setRAM("16GB")
                .setStorage("1TB SSD")
                .setGraphicsCard(true)
                .build();

        System.out.println("Computer created successfully!");
    }
}

Why Use the Builder Pattern?

• Improves code readability
• Avoids large and confusing constructors
• Allows creating immutable objects
• Makes object creation flexible and clean

Builder Pattern vs Constructor

Conclusion

The Builder Design Pattern is a clean and powerful way to create complex objects. It is widely used in real-world Java applications, frameworks, and APIs. Whenever you see object creation with chained methods, there is a high chance the Builder pattern is being used.

If you want clean, readable, and maintainable code, the Builder pattern is definitely worth using.