Why do we use builder design pattern rather than constructor-based object creation?

Question

Accepted Answer

The Builder Design Pattern is used to create complex objects in a readable and flexible manner, especially when an object contains many optional parameters. Instead of passing numerous arguments through constructors, the Builder pattern constructs the object step by step, making the code easier to understand, maintain, and extend.

Key Points:
• It eliminates the need for multiple overloaded constructors, often referred to as the telescoping constructor problem.
• Object creation becomes more readable because each parameter is explicitly specified during construction.
• It works particularly well with immutable classes, allowing all fields to be initialized before the object is created.

Example:
Consider an Employee object with fields such as id, name, email, department, salary, address, and phone number. Using constructors can become confusing due to the large number of parameters, whereas a Builder allows setting only the required fields and adding optional fields as needed.

Code Example:
```
public class Employee {

private final int id;
    private final String name;
    private final String email;

private Employee(EmployeeBuilder builder) {
        this.id = builder.id;
        this.name = builder.name;
        this.email = builder.email;
    }

public static class EmployeeBuilder {

private int id;
        private String name;
        private String email;

public EmployeeBuilder id(int id) {
            this.id = id;
            return this;
        }

public EmployeeBuilder name(String name) {
            this.name = name;
            return this;
        }

public EmployeeBuilder email(String email) {
            this.email = email;
            return this;
        }

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

public class Main {

public static void main(String[] args) {

Employee employee =
```
                new Employee.EmployeeBuilder()
                        .id(101)
                        .name("John")
                        .email("john@test.com")
```
                        .build();
    }
}
```
Interview Tip:
A concise interview answer is: We prefer the Builder Pattern over constructor-based object creation when an object has many optional parameters. It improves readability, avoids constructor overloading, supports immutability, and enables flexible step-by-step object creation.