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?

Answer 1

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