What is the Builder Pattern in Java? How is it different from the Factory Pattern?

The Builder Pattern is a creational design pattern used to construct complex objects in a step-by-step manner. It is especially useful when an object has many optional parameters or configurations. Instead of using multiple constructors, the Builder Pattern provides a readable and flexible way to create objects while keeping them immutable and easy to maintain.

Key Points: • Builder Pattern separates object construction from its representation, making object creation more flexible. • It improves code readability by allowing method chaining and avoids constructors with too many parameters. • Factory Pattern focuses on selecting and returning an appropriate object, while Builder Pattern focuses on how an object is constructed step by step.

Example: Consider creating a User object with fields like name, email, phone, address, age, and department. Using constructors can become confusing, whereas the Builder Pattern allows setting only the required fields and then building the final object in a readable way.

Code Example:

public class User {

    private String name;
    private String email;
    private int age;

    private User(Builder builder) {
        this.name = builder.name;
        this.email = builder.email;
        this.age = builder.age;
    }

    public static class Builder {

        private String name;
        private String email;
        private int age;

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

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

        public Builder age(int age) {
            this.age = age;
            return this;
        }

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

User user = new User.Builder() .name("John") .email("john@example.com") .age(30) .build();

Interview Tip: A concise interview answer is: The Builder Pattern is used to create complex objects step by step, especially when there are many optional parameters. It improves readability and flexibility. In contrast, the Factory Pattern is used to encapsulate object creation logic and return an appropriate object instance in a single step.