For N and NBuilder, should N be an instance variable of NBuilder, or all parameters of N be instance variables of NBuilder,finally new N() in build()?

Question

As far as I know about builder pattern, for example, an object, Student:

public class Student{
    private String name;
    private int age;
    //setter and getter
}

to apply builder pattern to Student, StudentBuilder should be like this:

Version 1 : Set Student as an instance variable of StudentBuilder

public class StudentBuilder{
    private Student _student;
    public void setName(String name){
        this._student.setName(name);
    }
    public void setAge(int age){
        this._student.setAge(age);
    }
    public Student build(){
        return this._student;
    }
}

However, after reading question and answer in this : https://softwareengineering.stackexchange.com/a/388062, as I know, the builder in the question uses the instance variables as parameters, like the following shows:

Version 2 : Set all the parameters of Student as instance variables of StudentBuilder first, finally new Student() and assign the instance variables of StudentBuilder to that new Student:

public class StudentBuilder{
    private String _name;
    private int _age;
    public void setName(String name){
        this._name=name;
    }
    public void setAge(int age){
        this._age(age);
    }
    public Student build(){
        Student student=new Student();
        student.setName(_name);
        student.setAge(_age);
        return student;
    }
}

My question is, version 1 and version 2, which is the proper builder pattern?

score 2 · Accepted Answer · answered Jun 24 '24 at 07:06

My question is, version 1 and 2, which is the proper builder pattern?

Both versions are proper implementations of the builder pattern.

The builder pattern is characterized by how the client code interacts with the <N>Builder class/object, but how it achieves the desired result is an implementation detail that is deemed unimportant for the design pattern.

That said, version 1 is an unusual implementation, because when that version is possible, there is not really a reason to use the builder pattern in the first place.

The main motivation for the builder pattern is that you need to instantiate a class N that cannot be instantiated with partial information and either

the required information gradually becomes available and the builder pattern gives you an easy location to collect it all, or
you want to emulate something like named constructor parameters in a language that doesn't support them

For N and NBuilder, should N be an instance variable of NBuilder, or all parameters of N be instance variables of NBuilder,finally new N() in build()?

1 Answers1