All 15 Design Patterns in Java questions
More in Design Patterns in Java
What is the Singleton pattern, and how would you implement a thread-safe Singleton in Java? What is the Factory Method pattern's simplest form -- a basic static factory returning different subtype instances based on input -- and why might you prefer it over exposing constructors directly? What is the Strategy pattern, and how do Java 8's functional interfaces and lambdas make implementing it significantly more concise than the traditional interface-plus-implementation-classes approach? What is the Factory Method pattern, and how does it differ from the simpler Static Factory Method idiom (like List.of() or Optional.of())? What is the Adapter pattern, and when would you use it to make an existing class compatible with an interface it wasn't originally designed to implement? What is the Template Method pattern, and how is it used to define the skeleton of an algorithm while letting subclasses customize specific steps? What is the difference between composition and inheritance as ways to reuse code, and why does the design principle "favor composition over inheritance" generally guide modern Java design (including many design patterns themselves)? How would you implement the Composite pattern to treat individual objects and groups of objects uniformly, such as a file system with files and directories? How would you implement the Observer pattern in Java, and how does it compare to using the built-in PropertyChangeSupport or a reactive streams library? How would you implement the Decorator pattern in Java, and how does java.io's InputStream/OutputStream class hierarchy exemplify this pattern in the JDK itself?
Advertisement
Back to results for “Design Patterns in Java”
Java › Design Patterns in Java

How does the Builder pattern solve the "telescoping constructor" problem, and how would you implement it for a class with many optional parameters?

Intermediate

Answer

The telescoping constructor problem arises when a class has many optional fields, leading to an unwieldy proliferation of overloaded constructors covering various combinations of provided parameters -- the Builder pattern instead uses a separate, often static nested Builder class with fluent setter-like methods (each returning `this` for chaining) that accumulate configuration before a final build() method constructs the actual immutable target object, giving readable, self-documenting object construction regardless of how many optional fields exist, without needing dozens of constructor overloads.
public class Pizza {
    private final String size;
    private final boolean cheese, pepperoni, mushroom;

    private Pizza(Builder b) {
        size = b.size; cheese = b.cheese; pepperoni = b.pepperoni; mushroom = b.mushroom;
    }

    public static class Builder {
        private final String size;
        private boolean cheese, pepperoni, mushroom;
        public Builder(String size) { this.size = size; }
        public Builder cheese(boolean val) { cheese = val; return this; }
        public Builder pepperoni(boolean val) { pepperoni = val; return this; }
        public Pizza build() { return new Pizza(this); }
    }
}

Pizza pizza = new Pizza.Builder("large").cheese(true).pepperoni(true).build();
Real-world example An HTTP client configuration class with a dozen optional settings (timeout, retry policy, headers, proxy, etc.) uses a Builder, letting callers set only the specific options relevant to them via readable chained method calls, avoiding both an unwieldy multi-parameter constructor and error-prone positional argument ordering.

Common follow-ups: How does Java's newer Record type relate to or compete with the Builder pattern for simpler cases?;What's the difference between this classic Builder pattern and Lombok's @Builder-generated equivalent?

Records & Sealed Classes;OOP & Classes
All 15 Design Patterns in Java questions