Why do we need to use the builder design pattern when we can do the same thing with setters? [duplicate]

Question

public class Employee {
    private String name;
    private String address;
    private int id;

    public Employee() {
        // TODO Auto-generated constructor stub
    }

    @Override
    public String toString() {
        return "Employee [name=" + name + ", address=" + address + ", id=" + id + "]";
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

}

public class Main { 
    public static void main(String[] args) {
        Employee e = new Employee();
        e.setName("Priyanka");
        Employee e1 = new Employee();
        e1.setName("Rahul");
        e1.setAddress("Delhi");
        System.out.println("Value of e :"+ e);
        System.out.println("Value of e1:"+ e1);
    }
}

Answer 1

The builder pattern can be useful to:

• apply some check on the data used to initialize the object. For example if you need a double check between variables
• create immutable objects. You can't change an object once initialized, so you can't use setters
• add readability of code.
• reduce the code used to initialize the object
• have the instance in a valid state. Using setters the object instance can be in a not valid state before all the setters are called.

---

Note on using the builder to create immutable objects.

When you work in a multithread environment an immutable object can be shared between threads without explicit synchronization. Because the object can't change during the time is not possible to have a race condition accessing and modifying it by two threads at the same time.