Patrón de diseño del constructor – java.Definición del patrón constructor | Por Gaurav Kumar Tyagi | Enero de 2022

El patrón Builder es un patrón de diseño creativo que le permite construir objetos complejos de forma incremental.

Este patrón no es muy útil cuando tienes un objeto simple, pero puedes usarlo sin dudarlo cuando empiezas a tener un objeto más complejo y quieres un código limpio.

El mejor ejemplo es Diálogo de alerta Las clases de AOSP, StringBuilder, DocumentBuilder son las mejores para ver cómo crear objetos complejos.

Crear clase interna estática nUnamed Builder (PersonBuilder) a pojo (Clase de persona). Agregue los mismos campos desde el pojo. Agregue también constructores y setters vacíos para cada campo, con un tipo de retorno de la clase Builder (PersonBuilder). Por último, pero no menos importante, la compilación del método agregado devolverá una nueva instancia del objeto Person.

public class Person {
private final String firstName;
private final String lastName;
private final int age;
private final String height;
private final String weight;
private final String eyesColor;
private final String hairColor;
private final String birthPlace;
private final Date birthDate;
private final int numberOfSibling;
private final boolean married;
				

					


						

							
Publicaciones relacionadas
						

						

							

								


			


			
					

	
	

		Así es el Redmi K50 Gaming Edition, el nuevo teléfono gaming de Xiaomi

		

			febrero 18, 2022		
	




			


			
					

	
	

		Cómo eliminar DoorDash de una tableta Android | Autor: Chris Basinger | Junio ​​de 2021

		

			junio 24, 2021		
	

							
						
					
				
				   // Private Constructor
private Person(PersonBuilder builder){
this.firstName = builder.firstName;
this.lastName = builder.lastName;
this.age = builder.age;
this.height = builder.height;
this.weight = builder.weight;
this.eyesColor = builder.eyesColor;
this.hairColor = builder.hairColor;
this.birthPlace = builder.birthPlace;
this.birthDate = builder.birthDate;
this.numberOfSibling = builder.numberOfSibling;
this.married = builder.married;
}
// Static Inner Class with same parameters
public static class PersonBuilder{
private String firstName;
private String lastName;
private int age;
private String height;
private String weight;
private String eyesColor;
private String hairColor;
private String birthPlace;
private Date birthDate;
private int numberOfSibling;
private boolean married;        public PersonBuilder(){}        public PersonBuilder setFirstName(String firstName){
this.firstName = firstName;
return this;
}
public PersonBuilder setLastName(String lastName){
this.lastName = lastName;
return this;
}
public PersonBuilder setAge(int age){
this.age = age;
return this;
}
public PersonBuilder setHeight(String height){
this.height = height;
return this;
}
public PersonBuilder setWeight(String weight){
this.weight = weight;
return this;
}
public PersonBuilder setEyesColor(String eyesColor){
this.eyesColor = eyesColor;
return this;
}
public PersonBuilder setHairColor(String hairColor){
this.hairColor = hairColor;
return this;
}
public PersonBuilder setBirthPlace(String birthPlace){
this.birthPlace = birthPlace;
return this;
}
public PersonBuilder setBirthDate(Date birthDate){
this.birthDate = birthDate;
return this;
}
public PersonBuilder setNumberOfSibling(int numberOfSibling){
this.numberOfSibling = numberOfSibling;
return this;
}
public PersonBuilder setMarried(boolean married){
this.married = married;
return this;
}
public Person build(){
Person person = new Person(this);
return person;
}
}
}

Código de creación del constructor:

Person person = new Person.PersonBuilder()
.setFirstName("Gaurav Tyagi")
.setAge(30)
.setBirthPlace("India")
.setMarried(true)
.setNumberOfSibling(2)
.build();

ventaja
1) Si el número de campos necesarios para crear un objeto supera los 4 o 5, el código es más fácil de mantener.
2) El código de creación de objetos es menos propenso a errores porque el usuario sabrá lo que está pasando debido a la llamada explícita al método.
3) El patrón constructor aumenta la solidez porque solo los objetos completamente construidos están disponibles para los clientes.
4) Puede obligar al objeto a permanecer sin cambios después de crearlo.