为什么强烈鼓励使用构建器模式，而不是在Java中直接实现流畅的API

Question

考虑以下生成器模式示例：

import java.util.Objects;
public class Vehicle {
private final String brand;
private final int wheels;
private final int doors;
private final int maxSpeed;
private Vehicle(Builder builder) {
this.brand = Objects.requireNonNull(builder.brand, "brand");
this.wheels = Objects.requireNonNull(builder.wheels, "wheels");
this.doors = Objects.requireNonNull(builder.doors, "doors");
this.maxSpeed = Objects.requireNonNull(builder.maxSpeed, "maxSpeed");
}
public static Builder builder() {
return new Builder();
}
public void display() {
System.out.println("brand = " + getBrand());
System.out.println("wheels = " + getWheels());
System.out.println("doors = " + getDoors());
System.out.println("maxSpeed = " + getMaxSpeed());
}
public String getBrand() {
return brand;
}
public int getWheels() {
return wheels;
}
public int getDoors() {
return doors;
}
public int getMaxSpeed() {
return maxSpeed;
}
public static class Builder {
private String brand;
private Integer wheels;
private Integer doors;
private Integer maxSpeed;
Builder() {
}
public Builder setBrand(String brand) {
this.brand = brand;
return this;
}
public Builder setWheels(int wheels) {
this.wheels = wheels;
return this;
}
public Builder setDoors(int doors) {
this.doors = doors;
return this;
}
public Builder setMaxSpeed(int maxSpeed) {
this.maxSpeed = maxSpeed;
return this;
}
public Builder of(Vehicle vehicle) {
this.brand = vehicle.brand;
this.wheels = vehicle.wheels;
this.doors = vehicle.doors;
this.maxSpeed = vehicle.maxSpeed;
return this;
}
public Vehicle build() {
return new Vehicle(this);
}
}
}

当我们创建Vehicle类型的对象时，我们有：

Vehicle vehicle = new Vehicle.Builder()
.setBrand("Mercedes")
.setWheels(4)
.setDoors(4)
.setMaxSpeed(250)
.build();

另一方面，可以在类别Vehicle的每个设置器中简单地return this，例如：

public class Vehicle {
private final String brand;
private final int wheels;
private final int doors;
private final int maxSpeed;
private Vehicle(String brand, int wheels, int doors, int maxSpeed){
this.brand = brand;
this.wheels = wheels;
this.doors = doors;
this.maxSpeed = maxSpeed;
}
public Vehicle() {
}
public String getBrand() {
return brand;
}
public int getWheels() {
return wheels;
}
public int getDoors() {
return doors;
}
public int getMaxSpeed() {
return maxSpeed;
}
public Vehicle setBrand(String brand) {
this.brand = brand;
return this;
}
public Vehicle setWheels(int wheels) {
this.wheels = wheels;
return this;
}
public Vehicle setDoors(int doors) {
this.doors = doors;
return this;
}
public Vehicle setMaxSpeed(int maxSpeed) {
this.maxSpeed = maxSpeed;
return this;
}
public void display() {
System.out.println("brand = " + getBrand());
System.out.println("wheels = " + getWheels());
System.out.println("doors = " + getDoors());
System.out.println("maxSpeed = " + getMaxSpeed());
}
}

我们可以通过以下方式创建Vehicle类型的对象：

Vehicle vehicle = new Vehicle();
vehicle.setBrand("Mercedes")
.setDoors(4)
.setMaxSpeed(250);

在我看来，第二种方法比传统的构建器模式生成的代码更少。尽管如此，我知道许多库都在使用构建器模式。那么，与第二种方法相比，构建器模式的优点是什么呢？

Answer 1

构建器模式与fluent api相比的一些好处：

1. Builder不仅可以返回Vehicle类，还可以返回SomeClass扩展Vehicle
2. 您可以将自定义复杂逻辑添加到构建方法中(验证、切换实现等(
3. 没有必要的属性就无法创建车辆

但如果你不需要这些好处，使用你的方法是绝对正常的。一些库使用