建造者模式的简单理解

建造者模式

1、原理图

2、个人见解

• 比如有一个产品，它有三个属性。

• public class Product {
  
      private String a;
      private String b;
      private String c;
  
  
      public String getA() {
          return a;
      }
  
      public void setA(String a) {
          this.a = a;
      }
  
      public String getB() {
          return b;
      }
  
      public void setB(String b) {
          this.b = b;
      }
  
      public String getC() {
          return c;
      }
  
      public void setC(String c) {
          this.c = c;
      }
  
      @Override
      public String toString() {
          return "Product{" +
                  "a='" + a + '\'' +
                  ", b='" + b + '\'' +
                  ", c='" + c + '\'' +
                  '}';
      }
  }
  

• 一个工人想去生产这个产品，就会new一下这个产品，再通过setter的方法给产品的属性注入值，然后通过一个方法返回这个产品。

• public class Worker01 {
      private Product product = new Product();
  
      public Product getProduct(){
          product.setA("a");
          product.setB("b");
          product.setC("c");
          return product;
      }
  
  }
  

• 有个指挥者居然想去控制这个工人的生产步骤，让这个工人只设置两个属性，或者换一下设置属性的顺序。

• 这时需要一个抽象类builder（一件工衣），声明了操作这个产品的属性的抽象方法，再加一个返回该产品的抽象方法。

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

• 然后让那个工人继承一下这个抽象类builder（穿上工衣），再去实现里面的抽象方法。对工人来说其实还是做原来该做的事情，只是要等指挥者指挥先操作哪个属性后再去操作哪个属性罢了。

• public class Worker extends Builder {
  
      private Product product;
  
      public Worker() {
          product = new Product();
      }
  
      void buildA() {
          product.setA("a");
          System.out.println("a");
      }
  
      void buildB() {
          product.setB("b");
          System.out.println("b");
  
      }
  
      void buildC() {
          product.setC("c");
          System.out.println("c");
      }
  
      Product getProduct() {
          return product;
      }
  
  
  }
  

• 看到了穿上工衣的工人，指挥者忍不住这就来指挥了，他指挥该工人只设置A和C属性，不管B属性了，最后生成的产品的B属性就为null

• public class Director {
  
  
      public Product build(Builder builder){
          builder.buildA();
          builder.buildC();
          builder.getProduct();
          return builder.getProduct();
      }
  
  
      public static void main(String[] args) {
          Director director = new Director();//呼叫指挥者
          Product build = director.build(new Worker());//指挥者指挥某个工人生产产品
          System.out.println(build);
      }
  }
  

3、适用场景：

• 隔离复杂对象的创建和使用，相同的方法，不同执行顺序，产生不同事件结果
• 多个部件都可以装配到一个对象中，但产生的运行结果不相同
• 产品类非常复杂或者产品类因为调用顺序不同而产生不同作用
• 初始化一个对象时，参数过多，或者很多参数具有默认值
• Builder模式不适合创建差异性很大的产品类
  产品内部变化复杂，会导致需要定义很多具体建造者类实现变化，增加项目中类的数量，增加系统的理解难度和运行成本
  复杂或者产品类因为调用顺序不同而产生不同作用
• 初始化一个对象时，参数过多，或者很多参数具有默认值
• Builder模式不适合创建差异性很大的产品类
  产品内部变化复杂，会导致需要定义很多具体建造者类实现变化，增加项目中类的数量，增加系统的理解难度和运行成本
• 需要生成的产品对象有复杂的内部结构，这些产品对象具备共性；