How to use Java builder pattern to build complex objects

Introduction

The builder pattern in Java is a creational design pattern. Its main purpose is to build complex objects through a series of simple steps, allowing the creation of different representations of complex objects. At the same time, the construction details are hidden. It can build objects step by step, that is, first create a basic object, and then gradually add more properties or components until a complete object is finally built.

The main idea of ​​this pattern is to combine the construction of objects The process is broken down into multiple steps, each step can be run independently, and an intermediate state can be returned after each step is completed, and then a director class is used to coordinate these steps and finally create a complete object.

Builder pattern usually includes the following roles:

• Product class (Product): a constructed complex object with multiple properties or components.

• Abstract constructor class (Builder): defines the methods and attributes required to build complex objects.

• Concrete builder class (ConcreteBuilder): implements the abstract builder class Methods and properties defined in, and return the final constructed object

• Director class (Director): Responsible for coordinating the construction process of each specific builder class, and returning the final constructed object,

Implementation

First create a product class

package com.fanqiechaodan.build;
import lombok.Data;
/**
 * @Classname Car
 * @Description 产品类
 */
@Data
public class Car {
    private String brand;
    private String model;
    private String color;
    private int maxSpeed;
}

Secondly create an abstract builder class

package com.fanqiechaodan.build;
/**
 * @Classname CarBuilder
 * @Description 抽象建造者类
 */
public abstract class CarBuilder {
    protected Car car;
    public CarBuilder(){
        car = new Car();
    }
    public abstract void buildBrand();
    public abstract void buildModel();
    public abstract void buildColor();
    public abstract void buildMaxSpeed();
    public Car getCar() {
        return car;
    }
}

Then create a concrete constructor class

package com.fanqiechaodan.build;
/**
 * @Classname BMWBuilder
 * @Description 具体构造者类
 */
public class BMWBuilder extends CarBuilder {
    @Override
    public void buildBrand() {
        car.setBrand("BMW");
    }
    @Override
    public void buildModel() {
        car.setModel("X6");
    }
    @Override
    public void buildColor() {
        car.setColor("Black");
    }
    @Override
    public void buildMaxSpeed() {
        car.setMaxSpeed(218);
    }
}

Create Director Class

package com.fanqiechaodan.build;
/**
 * @Classname Director
 * @Description 导演类
 */
public class Director {
    private CarBuilder carBuilder;
    public Director(CarBuilder carBuilder) {
        this.carBuilder = carBuilder;
    }
    public Car constructCar() {
        carBuilder.buildBrand();
        carBuilder.buildColor();
        carBuilder.buildMaxSpeed();
        carBuilder.buildModel();
        return carBuilder.getCar();
    }
}

Test

package com.fanqiechaodan.build;
/**
 * @Classname Demo
 * @Description 建造者模式
 */
public class Demo {
    public static void main(String[] args) {
        CarBuilder carBuilder = new BMWBuilder();
        Director director = new Director(carBuilder);
        Car car = director.constructCar();
        System.out.println(car.toString());
    }
}

The above is the detailed content of How to use Java builder pattern to build complex objects. For more information, please follow other related articles on the PHP Chinese website!