📝 What You’ll Learn

• What the Builder Pattern is
• Why it’s useful for constructing complex objects
• How to implement it in Java
• Real-world analogy and example
• Pitfalls and best practices

🔍 What Is the Builder Pattern?

The Builder Pattern is used to construct complex objects with many optional parts or configurations.

Instead of having constructors with tons of parameters, Builder provides a step-by-step construction process with method chaining.

🏗️ When Should You Use It?

• When a class has many constructor parameters (some optional)
• When you want to avoid constructor telescoping
• When object creation should be separated from its representation

🧱 Java Implementation

🧩 Step 1: Define the Product Class

public class Burger {
    private String bun;
    private String patty;
    private boolean cheese;
    private boolean lettuce;
    private boolean tomato;

    private Burger(Builder builder) {
        this.bun = builder.bun;
        this.patty = builder.patty;
        this.cheese = builder.cheese;
        this.lettuce = builder.lettuce;
        this.tomato = builder.tomato;
    }

    public static class Builder {
        private String bun;
        private String patty;
        private boolean cheese;
        private boolean lettuce;
        private boolean tomato;

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

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

        public Builder cheese(boolean value) {
            this.cheese = value;
            return this;
        }

        public Builder lettuce(boolean value) {
            this.lettuce = value;
            return this;
        }

        public Builder tomato(boolean value) {
            this.tomato = value;
            return this;
        }

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

✅ Usage

Burger burger = new Burger.Builder()
    .bun("Whole Wheat")
    .patty("Beef")
    .cheese(true)
    .lettuce(true)
    .tomato(false)
    .build();

🍔 Real-World Analogy

Think of building a custom burger. You choose the bun, patty, cheese, and toppings — all optional. The builder gives you flexibility and control.

⚠️ Pitfalls to Avoid

• ❌ Forgetting to make the constructor private in the main class
• ❌ Overcomplicating small objects that don’t need builders
• ❌ Mixing builder with mutable state after building

✅ Best Practices

• Use fluent interfaces for readability
• Keep the builder class static and inside the product class
• Ensure immutability of the final built object
• Consider using Lombok’s @Builder to automate builder generation

📘 Recap

• Builder pattern is perfect for complex object creation
• It prevents bloated constructors and improves readability
• Promotes immutability and clear, fluent APIs
• Widely used in APIs like Java Streams, StringBuilder, etc.