Java中的设计模式之建造者模式

建造者模式是一种设计模式，它允许您创建复杂的对象，而无需在构造函数中指定所有的内部细节。 它通过将对象的构建和它的表示分离开来，使得您可以创建不同的表示。

在 Java 中，您可以使用建造者模式来创建对象。 下面是一个示例，该示例演示了如何使用建造者模式来创建一个简单的电脑：

public class Computer {
   // required parameters
   private String HDD;
   private String RAM;
   
   // optional parameters
   private boolean isGraphicsCardEnabled;
   private boolean isBluetoothEnabled;
   
   public static class Builder {
      // required parameters
      private String HDD;
      private String RAM;
      
      // optional parameters
      private boolean isGraphicsCardEnabled;
      private boolean isBluetoothEnabled;
      
      public Builder(String hdd, String ram) {
         this.HDD = hdd;
         this.RAM = ram;
      }
      
      public Builder setGraphicsCardEnabled(boolean isGraphicsCardEnabled) {
         this.isGraphicsCardEnabled = isGraphicsCardEnabled;
         return this;
      }
      
      public Builder setBluetoothEnabled(boolean isBluetoothEnabled) {
         this.isBluetoothEnabled = isBluetoothEnabled;
         return this;
      }
      
      public Computer build() {
         return new Computer(this);
      }
   }
   
   private Computer(Builder builder) {
      this.HDD = builder.HDD;
      this.RAM = builder.RAM;
      this.isGraphicsCardEnabled = builder.isGraphicsCardEnabled;
      this.isBluetoothEnabled = builder.isBluetoothEnabled;
   }
}

使用建造者模式创建电脑的示例如下所示：

Computer computer = new Computer.Builder("500 GB", "2 GB")
   .setGraphicsCardEnabled(true)
   .setBluetoothEnabled(true)
   .build();

在这里，我们创建了一个名为 Computer 的类，该类具有必需的参数 HDD 和 RAM这意味着在创建 Computer 对象时，必须提供这两个参数的值。

此外，Computer 类还具有两个可选参数 isGraphicsCardEnabled 和 isBluetoothEnabled，这意味着在创建 Computer 对象时，可以选择性地提供这两个参数的值。

为了方便地创建 Computer 对象，我们使用了建造者模式。 建造者模式允许我们使用一个内部类 Builder 来构建 Computer 对象。 Builder 类包含所有的参数，并允许我们在创建 Computer 对象时选择性地设置这些参数。

这里是另一个使用建造者模式创建汉堡的示例：

public class Burger {
   private final String bun;
   private final String meat;
   private final String sauce;
   private final String cheese;
   private final String lettuce;
   private final String tomato;
   private final String pickles;
   private final String onions;
   private final String ketchup;
   private final String mustard;
   private final String mayo;
   
   public static class Builder {
      // required parameters
      private final String bun;
      private final String meat;
      
      // optional parameters
      private String sauce;
      private String cheese;
      private String lettuce;
      private String tomato;
      private String pickles;
      private String onions;
      private String ketchup;
      private String mustard;
      private String mayo;
      
      public Builder(String bun, String meat) {
         this.bun = bun;
         this.meat = meat;
      }
      
      public Builder sauce(String val) {
         sauce = val;
         return this;
      }
      
      public Builder cheese(String val) {
         cheese = val;
         return this;
      }
      
      public Builder lettuce(String val) {
         lettuce = val;
         return this;
      }
      
      public Builder tomato(String val) {
         tomato = val;
         return this;
      }
      
      public Builder pickles(String val) {
         pickles = val;
         return this;
      }
      
      public Builder onions(String val) {
         onions = val;
         return this;
      }
      
      public Builder ketchup(String val) {
         ketchup = val;
         return this;
      }
      
      public Builder mustard(String val) {
         mustard = val;
         return this;
      }
      
      public Builder mayo(String val) {
         mayo = val;
         return this;
      }
      
      public Burger build() {
         return new Burger(this);
      }
   }
   
   private Burger(Builder builder) {
      bun = builder.bun;
      meat = builder.meat;
      sauce = builder.sauce;
      cheese = builder.cheese;
      lettuce = builder.lettuce;
      tomato = builder.tomato;
      pickles = builder.pickles;
      onions = builder.onions;
      ketchup = builder.ketchup;
      mustard = builder.mustard;
      mayo = builder.mayo;
   }
}

使用建造者模式创建汉堡的示例如下所示：

Burger burger = new Burger.Builder("bun", "beef patty")
   .cheese("cheddar")
   .lettuce("iceberg")
   .tomato("vine ripened")
   .build();

在这里，我们使用建造者模式创建了一个名为 Burger 的类，该类具有多个可选参数，如肉，芝士，生菜，番茄等。 我们使用内部类 Builder 来构建 Burger 对象，并使用链式调用来设置所有可选参数。

最后，我们使用 build() 方法来创建 Burger 对象。 在这里，我们提供了两个必需的参数 bun 和 meat，并选择性地提供了其他几个可选参数的值。

建造者模式非常有用，因为它允许您创建复杂的对象，而无需在构造函数中指定所有的内部细节。 它还使得您可以使用不同的表示来创建相同类型的对象，这在某些情况下可能非常有用。

您可以使用 Lombok 库来简化使用建造者模式的代码。 下面是一个使用 Lombok 的建造者模式创建简单的汽车的示例：

@Builder
public class Car {
   private String make;
   private String model;
   private int year;
}

在这里，我们使用 @Builder 注解来生成内部类 Builder 和所有参数的 setter 方法。 您可以使用链式调用来设置所有参数，并使用 build() 方法来创建 Car 对象。

使用 Lombok 的建造者模式创建汽车的示例如下所示：

Car car = Car.builder()
   .make("Toyota")
   .model("Camry")
   .year(2020)
   .build();

使用 Lombok 可以大大简化使用建造者模式的代码，并减少常见错误的发生。 它还使您可以轻松地扩展类，而无需修改构造函数或建造者类。