We have a class person
with 30 paramaeters.
public class
Person {
@Override
public
String toString() {
return "Person
[fname=" + fname + ",
mname=" + mname + ",
lname="
+ lname + "]";
}
private
String fname;
private
String mname;
private
String lname;
public
Person(String fname, String mname, String lname) {
super();
this.fname =
fname;
this.mname =
mname;
this.lname =
lname;
}
When we want to create an obj.
Person
person = new Person("pariks", "", "Sharma");
If thre are 30 parameters..
Person(String fname) { ... }
Person (String fname, String lname) { ... }
Person (String fname, String mname,
String lname) { ... }
This is called the Telescoping
Constructor Pattern. The problem with this pattern is that once constructors
are 4 or 5 parameters long it becomes difficult to remember the required order
of the parameters as well as what particular constructor you might want in a
given situation.
Person person = new Person ();
person.setFname (“parikshit”);
person.setLname(“sharma”);
person.setMname(“”);
The problem here is that because the
object is created over several calls it may be in an inconsistent state partway
through its construction. This also requires a lot of extra effort to ensure
thread safety.
static class
PersonBuilder {
private
String fname;
private
String mname;
private
String lname;
public
PersonBuilder setFname(String fname) {
this.fname =
fname;
return this;
}
public
PersonBuilder setMname(String mname) {
this.mname =
mname;
return this;
}
public
PersonBuilder setLname(String lname) {
this.lname =
lname;
return this;
}
public
PersonBuilder() {
// TODO
Auto-generated constructor stub
}
Person createPerson() {
return new
Person(fname, mname, lname);
}
}
}
Now create
public class
PersonBuilderTest {
public static void
main(String[] args) {
Person person
= new Person("pariks", "", "Sharma");
Person person = new Person.PersonBuilder().setFname("parik")
.setLname("sharma").setMname("").createPerson();
System.out.println(person);
}
}
No comments:
Post a Comment