What is Builder Design Pattern in Java?
The Builder Design Pattern is a structural design pattern that is used to separate the construction of a complex object from its representation. It allows the same construction process to create different representations of the object. In Java, the Builder pattern is particularly useful when you have a class with many optional parameters, as it helps to create objects with a specific subset of these parameters without overwhelming the constructor with too many parameters.
The main idea behind the Builder pattern is to separate the object construction process into a series of steps, each responsible for building a part of the object. This separation makes the code more readable, maintainable, and flexible. By using the Builder pattern, you can create objects with a specific configuration without exposing the internal representation of the object to the client code.
In Java, the Builder pattern typically involves three components:
1. Product: This is the complex object that is being constructed. It represents the final result of the construction process.
2. Builder: This is an interface that defines a set of methods for constructing the product. Each method corresponds to a step in the construction process.
3. Director: This is a class that uses the Builder interface to construct the product. It is responsible for the overall construction process and coordinates the interaction between the Builder and the Product.
Here is a simple example to illustrate the Builder pattern in Java:
“`java
// Product class
class Computer {
private String cpu;
private String ram;
private String disk;
public String getCpu() {
return cpu;
}
public String getRam() {
return ram;
}
public String getDisk() {
return disk;
}
}
// Builder interface
interface ComputerBuilder {
void setCPU(String cpu);
void setRAM(String ram);
void setDisk(String disk);
Computer build();
}
// Concrete Builder class
class ConcreteComputerBuilder implements ComputerBuilder {
private Computer computer;
public ConcreteComputerBuilder() {
computer = new Computer();
}
@Override
public void setCPU(String cpu) {
computer.setCpu(cpu);
}
@Override
public void setRAM(String ram) {
computer.setRam(ram);
}
@Override
public void setDisk(String disk) {
computer.setDisk(disk);
}
@Override
public Computer build() {
return computer;
}
}
// Director class
class ComputerDirector {
private ComputerBuilder builder;
public ComputerDirector(ComputerBuilder builder) {
this.builder = builder;
}
public void constructComputer(String cpu, String ram, String disk) {
builder.setCPU(cpu);
builder.setRAM(ram);
builder.setDisk(disk);
}
}
// Client code
public class BuilderPatternExample {
public static void main(String[] args) {
ComputerBuilder builder = new ConcreteComputerBuilder();
ComputerDirector director = new ComputerDirector(builder);
director.constructComputer(“Intel i7”, “16GB”, “1TB SSD”);
Computer computer = builder.build();
System.out.println(“Computer CPU: ” + computer.getCpu());
System.out.println(“Computer RAM: ” + computer.getRam());
System.out.println(“Computer Disk: ” + computer.getDisk());
}
}
“`
In this example, the `Computer` class represents the product, the `ConcreteComputerBuilder` class implements the `ComputerBuilder` interface, and the `ComputerDirector` class is responsible for constructing the `Computer` object using the `ConcreteComputerBuilder`. The client code demonstrates how to use the Builder pattern to create a `Computer` object with a specific configuration.
