The Builder Pattern

The Builder pattern constructs a complex, usually immutable object step by step through a fluent helper class — replacing confusing multi-argument constructors with readable, named, chainable calls.

Learn The Builder Pattern in our free Java course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a quick reference.

Part of the free Java course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

You should know classes, constructors and access modifiers , and ideally the previous lesson on immutability — builders and immutable objects are natural partners.

💡 Analogy: A telescoping constructor is like ordering by shouting " one, twelve, true, false, true! " and hoping the kitchen guesses what each value means. A Builder is the sandwich shop counter: you say " start with a footlong, add cheese, add mushrooms, hold the pepperoni ", one clear instruction at a time, and only when you say " that's it " ( build() ) does the kitchen check your order is valid and hand over the finished, sealed sandwich. You configured a mutable order; you received an immutable meal.

Each instruction is named , so nobody confuses cheese for mushrooms — and the order can't go out the door until it passes the final check.

With several optional fields you end up with a ladder of constructors, and call sites become a row of mystery true / false values. Which flag is which? You can't tell without opening the class. Add one option and you add another constructor.

Move construction into a static nested Builder . Required values go to the builder's constructor; optional ones get named methods that set a field and return this so calls chain. The product's constructor is private and takes the builder, so objects can only be made the validated way.

The setters just record values; build() is the one place where the whole object exists, so it's where you validate. Check required fields and cross-field rules there, throwing IllegalStateException if anything is off — an invalid object is then never created.

Answer: chaining would break — builder.cheese().mushroom() wouldn't compile because cheese() would return nothing for mushroom() to call. Each fluent method must return this .

Answer: so the only path to an instance is through the builder's build() , which guarantees validation runs and the object is complete. A public constructor would let callers bypass all of that.

Answer: in build() . Only there does the whole object exist, so cross-field rules can be checked. Setters just record intent.

🎯 YOUR TURN — Finish the Burger builder

Complete the nested Builder : a patties(int) setter, a no-arg cheese() flag, and build() — all chainable.

🧩 MINI-CHALLENGE — Config builder with defaults & validation

Build an immutable HttpRequestConfig with a required URL, defaulted method/timeout, and validation in build() .

You can now recognise the telescoping-constructor problem, write a static nested Builder with fluent return this setters, validate in build() , produce an immutable result through a private constructor, and judge when a builder beats a plain constructor or record.

Next up: Dependency Injection — wiring objects together from the outside so your code is decoupled and testable.

Practice quiz

• Browse all free courses
• Cheat sheets & quizzes
• Coding dictionary