[设计模式]建造者模式

一、什么是建造者模式？

建造者模式也属于创建型模式，它提供了一种创建对象的最佳方式。将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示，在用户不知道对象的建造过程和细节的情况下就可以直接创建复杂的对象。用户只需要给出指定复杂对象的类型和内容，建造者模式负责按顺序创建复杂对象（把内部的建造过程和细节隐藏起来）。

二、建造者模式的优点

• 产品的建造和表示分离，实现了解耦。
• 将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰。
• 具体的建造者类是相互独立的，有利于系统的拓展。

三、建造者模式的缺点

• 建造者模式锁创建的产品一般具有较多的共同点，其组成部分相似；如果产品之间的差异较大，则不适合使用建造者模式。
• 如果产品的内部变化复杂，可能会导致需要很多建造者类来实现这种变化。

四、代码实现建造者模式

1、普通的建造者模式

• 抽象的建造者类

  public abstract class Builder {
      abstract void buildA();
      abstract void buildB();
      abstract void buildC();
      abstract void buildD();
  
      abstract Product getProduct();
  }
  

• 产品类

  public class Product {
  
      private String buildA;
      private String buildB;
      private String buildC;
      private String buildD;
  
      public String getBuildA() {
          return buildA;
      }
  
      public void setBuildA(String buildA) {
          this.buildA = buildA;
      }
  
      public String getBuildB() {
          return buildB;
      }
  
      public void setBuildB(String buildB) {
          this.buildB = buildB;
      }
  
      public String getBuildC() {
          return buildC;
      }
  
      public void setBuildC(String buildC) {
          this.buildC = buildC;
      }
  
      public String getBuildD() {
          return buildD;
      }
  
      public void setBuildD(String buildD) {
          this.buildD = buildD;
      }
  
      @Override
      public String toString() {
          return "Product{" +
                  "buildA=‘" + buildA + ‘\‘‘ +
                  ", buildB=‘" + buildB + ‘\‘‘ +
                  ", buildC=‘" + buildC + ‘\‘‘ +
                  ", buildD=‘" + buildD + ‘\‘‘ +
                  ‘}‘;
      }
  }
  

• 具体的建造者类

  public class Worker  extends  Builder{
      private Product product;
  
      public Worker() {
          this.product = new Product();
      }
  
      @Override
      void buildA() {
          product.setBuildA("地基");
          System.out.println("地基");
      }
  
      @Override
      void buildB() {
          product.setBuildB("钢筋工程");
          System.out.println("钢筋工程");
      }
  
      @Override
      void buildC() {
          product.setBuildC("铺电线");
          System.out.println("铺电线");
      }
  
      @Override
      void buildD() {
          product.setBuildD("粉刷");
          System.out.println("粉刷");
      }
  
      @Override
      Product getProduct() {
          return product;
      }
  }
  

• 指挥类

  public class Director {
  
      public Product build(Builder builder){
          builder.buildA();
          builder.buildB();
          builder.buildC();
          builder.buildD();
          return builder.getProduct();
      }
  
  }
  

• 测试类

  public class TestBuilder {
  
      public static void main(String[] args) {
          Director director = new Director();
          Product build = director.build(new Worker());
          System.out.println(build.toString());
      }
  }
  

• 运行结果

  地基
  钢筋工程
  铺电线
  粉刷
  Product{buildA=‘地基‘, buildB=‘钢筋工程‘, buildC=‘铺电线‘, buildD=‘粉刷‘}
  

2、省去指挥者类的建造者模式（通过链式编程实现）

• 抽象的建造者类

  public abstract class Builder {
  
      abstract Builder buildA(String msg);
      abstract Builder buildB(String msg);
      abstract Builder buildC(String msg);
      abstract Builder buildD(String msg);
  
      abstract Product getProduct();
  
  }
  

• 产品类

  public class Product {
      private String buildA = "汉堡";
      private String buildB = "薯条";
      private String buildC = "可乐";
      private String buildD = "西瓜";
  
      public String getBuildA() {
          return buildA;
      }
  
      public void setBuildA(String buildA) {
          this.buildA = buildA;
      }
  
      public String getBuildB() {
          return buildB;
      }
  
      public void setBuildB(String buildB) {
          this.buildB = buildB;
      }
  
      public String getBuildC() {
          return buildC;
      }
  
      public void setBuildC(String buildC) {
          this.buildC = buildC;
      }
  
      public String getBuildD() {
          return buildD;
      }
  
      public void setBuildD(String buildD) {
          this.buildD = buildD;
      }
  
      @Override
      public String toString() {
          return "Product{" +
                  "buildA=‘" + buildA + ‘\‘‘ +
                  ", buildB=‘" + buildB + ‘\‘‘ +
                  ", buildC=‘" + buildC + ‘\‘‘ +
                  ", buildD=‘" + buildD + ‘\‘‘ +
                  ‘}‘;
      }
  }
  

• 具体的建造者类

  public class Worker extends Builder {
  
      private Product product;
  
      public Worker(){
          product = new Product();
      }
  
      @Override
      Builder buildA(String msg) {
          product.setBuildA(msg);
          return this;
      }
  
      @Override
      Builder buildB(String msg) {
          product.setBuildB(msg);
          return this;
      }
  
      @Override
      Builder buildC(String msg) {
          product.setBuildC(msg);
          return this;
      }
  
      @Override
      Builder buildD(String msg) {
          product.setBuildD(msg);
          return this;
      }
  
      @Override
      Product getProduct() {
          return product;
      }
  }
  

• 测试类

  public class TestBuilder {
  
      public static void main(String[] args) {
          Worker worker = new Worker();
          Product product = worker.buildA("嫩牛五方").getProduct();
  
          System.out.println(product.toString());
      }
  
  }
  

• 运行结果

  Product{buildA=‘嫩牛五方‘, buildB=‘薯条‘, buildC=‘可乐‘, buildD=‘西瓜‘}
  

[设计模式]建造者模式

原文：https://www.cnblogs.com/baihan/p/13112150.html