How can you implement the Builder design pattern in OOP?

3 The Product Class

The first step is to define the product class, which in this case is the Car class. The Car class has a list of parts as its attributes, and a method to display the parts. The Car class does not have any logic or behavior, it only represents the final product.

public class Car {
  private List<String> parts;
  public Car() {
    parts = new ArrayList<String>();
  }
  public void addPart(String part) {
    parts.add(part);
  }
  public void showParts() {
    System.out.println("Car parts: " + parts);
  }
}        

4 The Builder Interface

The next step is to define the builder interface, which in this case is the CarBuilder interface. The CarBuilder interface has a method for each step of the construction process, such as buildChassis, buildEngine, buildWheels, etc. Each method returns a CarBuilder instance, to allow method chaining. The CarBuilder interface also has a method to return the final product, which is a Car instance.

public interface CarBuilder {
  public CarBuilder buildChassis();
  public CarBuilder buildEngine();
  public CarBuilder buildWheels();
  public CarBuilder buildDoors();
  public CarBuilder buildSeats();
  public Car getCar();
}        

5 The Concrete Builder Classes

The third step is to define the concrete builder classes, which implement the builder interface and provide the specific details for each part of the product. For example, we can define a SedanBuilder class, an SUVBuilder class, and a SportsCarBuilder class, each with different specifications for the chassis, engine, wheels, doors, and seats. Each concrete builder class also has a Car instance as its attribute, which is the product that it builds.

public class SedanBuilder implements CarBuilder {
  private Car car;
  public SedanBuilder() {
    car = new Car();
  }
  public CarBuilder buildChassis() {
    car.addPart("Sedan chassis");
    return this;
  }
  public CarBuilder buildEngine() {
    car.addPart("Sedan engine");
    return this;
  }
  public CarBuilder buildWheels() {
    car.addPart("Sedan wheels");
    return this;
  }
  public CarBuilder buildDoors() {
    car.addPart("Sedan doors");
    return this;
  }
  public CarBuilder buildSeats() {
    car.addPart("Sedan seats");
    return this;
  }
  public Car getCar() {
    return car;
  }
}
// Similarly, define the SUVBuilder and SportsCarBuilder classes        

6 The Director Class

The fourth step is to define the director class, which controls the construction process and uses the builder interface to create the product. The director class has a CarBuilder instance as its attribute, and a method to construct the car. The method takes the CarBuilder instance as a parameter, and calls the builder methods in a specific order. The method also returns the final product, which is a Car instance.

public class CarDirector {
  private CarBuilder carBuilder;
  public CarDirector(CarBuilder carBuilder) {
    this.carBuilder = carBuilder;
  }
  public Car constructCar() {
    return carBuilder.buildChassis()
                     .buildEngine()
                     .buildWheels()
                     .buildDoors()
                     .buildSeats()
                     .getCar();
  }
}        

8 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?