Example of Builder Method in Java
Assume we have a ‘Person‘ class with several optional attributes like ‘firstName’, ‘lastName’, ‘age’, ‘address’, and ‘phone’. We can use the Builder pattern to create instances of ‘Person’ more intuitively and cleanly.
Key Component of Builder Design Pattern in Java
- First create a Builder class with methods for setting the optional parameters of the object that we want to create.
- Create a Director class (optional) that orchestrates the construction process by using the Builder.
- Create the Product class, which represents the complex object you want to build. This class should have a private constructor and a public static inner Builder class.
So here in this example the ‘Person‘ class has a nested ‘PersonBuilder‘ class, which allows us to set optional attributes using chained method calls. The ‘build‘ method creates a ‘Person‘ object with the specified attributes, and it enforces that required attributes like firstName and lastName are set.
Step wise Implementation for Builder Pattern in Java:
Let’s take a look at how the Builder pattern works in Java:
1. Create the Product Class:
First, we have to define the class for the product we want to build. This class should have attributes that need to be set during the construction process. These attributes can be optional or mandatory.
Java
public class Product { private String attribute1; private String attribute2; private int attribute3; // Constructor (usually private to enforce the use of the Builder) private Product(String attribute1, String attribute2, int attribute3) { this.attribute1 = attribute1; this.attribute2 = attribute2; this.attribute3 = attribute3; } // Getter methods public String getAttribute1() { return attribute1; } public String getAttribute2() { return attribute2; } public int getAttribute3() { return attribute3; }} |
2. Create the Builder Class
Next, we have to create a separate builder class for the product. The builder class has methods to set the various attributes of the product. It also contains a build method to create the final product instance.
Java
public class ProductBuilder { private String attribute1; private String attribute2; private int attribute3; public ProductBuilder setAttribute1(String attribute1) { this.attribute1 = attribute1; return this; } public ProductBuilder setAttribute2(String attribute2) { this.attribute2 = attribute2; return this; } public ProductBuilder setAttribute3(int attribute3) { this.attribute3 = attribute3; return this; } public Product build() { return new Product(attribute1, attribute2, attribute3); }} |
3. Using the Builder
To create a Product instance, we want to use the ProductBuilder class to set the desired attributes and then call the build method to obtain the final product.
Java
public class Main { public static void main(String[] args) { Product product = new ProductBuilder() .setAttribute1("Value1") .setAttribute2("Value2") .setAttribute3(42) .build(); System.out.println("Product created with attributes:"); System.out.println("Attribute1: " + product.getAttribute1()); System.out.println("Attribute2: " + product.getAttribute2()); System.out.println("Attribute3: " + product.getAttribute3()); }} |
Overall Implementation for Builder Design in Java
Java
public class Person { private String firstName; private String lastName; private int age; private String address; private String phone; private Person(PersonBuilder builder) { this.firstName = builder.firstName; this.lastName = builder.lastName; this.age = builder.age; this.address = builder.address; this.phone = builder.phone; } // Getters for attributes public static class PersonBuilder { private String firstName; private String lastName; private int age; private String address; private String phone; public PersonBuilder(String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; } public PersonBuilder age(int age) { this.age = age; return this; } public PersonBuilder address(String address) { this.address = address; return this; } public PersonBuilder phone(String phone) { this.phone = phone; return this; } public Person build() { return new Person(this); } } @Override public String toString() { return "Person [firstName=" + firstName + ", lastName=" + lastName + ", age=" + age + ", address=" + address + ", phone=" + phone + "]"; } public static void main(String[] args) { Person person = new PersonBuilder("John", "Doe") .age(30) .address("123 Main St") .phone("555-1234") .build(); System.out.println(person); }} |
Person [firstName=John, lastName=Doe, age=30, address=123 Main St, phone=555-1234]
Diagrammatic Representation for Builder Design Pattern in Java
working
So by using the Builder pattern, we can create a Product object step by step, setting only the attributes that are necessary, and leaving the others with default values or null if applicable. This approach makes the code more readable and allows for flexible construction of objects with various configurations. It also prevents the need for large constructors with multiple parameters and improves code maintainability.
Builder, Fluent Builder, and Faceted Builder Method Design Pattern in Java
Builder Pattern is defined as a creational design pattern that is used to construct a complex object step by step. It separates the construction of an object from its representation, allowing us to create different variations of an object with the same construction code. This pattern is particularly useful when dealing with a complex object with many optional parameters or configurations.
Important Topics for Builder Design Pattern in Java
- Use Cases of the Builder Pattern in Java
- Example for Builder Method in Java:
- What is Fluent Builder ?
- What is Faceted Builder?