Provide an example of when using a Builder pattern is preferable over multiple constructors.

The Builder pattern is preferable to multiple constructors whenever an object has many optional attributes, since a constructor-per-combination approach becomes unmanageable while a builder lets callers set only the fields they care about, in a readable way.

Key Points: • Telescoping constructors (one overload per parameter combination) become unreadable and error-prone once an object has more than a few optional fields. • A builder exposes fluent setter-like methods, so the caller specifies only the relevant attributes, in any order. • Builders make the resulting construction code self-documenting, since each field is named explicitly at the call site. • The built object can be made immutable, with the builder assembling all fields before a single build() call constructs it. • Validation of required fields or valid combinations can happen once, inside build(), rather than being duplicated across constructor overloads.

Example: Configuring a Computer with optional RAM, storage type, GPU, and OS would require a dozen constructor overloads to cover common combinations, but a ComputerBuilder lets you call only .ram(16).storage("SSD").build() and skip the fields you don't need.

Code Example:

class Computer {
    private final int ram;
    private final String storage;

    private Computer(Builder b) {
        this.ram = b.ram;
        this.storage = b.storage;
    }

    static class Builder {
        private int ram = 8;
        private String storage = "HDD";

        Builder ram(int ram) { this.ram = ram; return this; }
        Builder storage(String storage) { this.storage = storage; return this; }
        Computer build() { return new Computer(this); }
    }
}

Interview Tip: A concise interview answer is:

"Once an object has several optional attributes, like configuring a computer with RAM, storage, and GPU options, a constructor for every valid combination becomes unmanageable. A Builder lets the caller set only the fields that matter, in a readable, self-documenting way, and still produce an immutable object at the end."