介绍

  1. 建造者模式（BuilderPattern）又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。
  2. 建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。

个人总结
原来建房，建房子的信息（地基，屋顶，墙）和建（地基，屋顶，墙）方法，和建房子步骤封装在一个类中，客户直接把房子new（）出来就可以。

现在建房子，房子类只是一个状态类（只有房子的属性），房子的属性（地基，屋顶，墙）建造方法由建造者负责，房子的建造步骤（先建地基，再砌墙，最后盖屋顶）由指挥者负责，客户只需要调用指挥者的相关方法就可以完成房子的构建

案例

盖房项目需求

  1. 需要建房子：这一过程为打桩、砌墙、封顶
  2. 房子有各种各样的，比如普通房，高楼，别墅，各种房子的过程虽然一样，但是要求不要相同的.

image-20200927150304682.png

  1. //房子（需要地基，墙壁，屋顶）
  2. public class House {
  3.      private String base;
  4.      private String wall;
  5.      private String roof;
  7.      public String getBase() {
  8.           return base;
  9.      }
  10.      public void setBase(String base) {
  11.           this.base = base;
  12.      }
  14.      public String getWall() {
  15.           return wall;
  16.      }
  18.      public void setWall(String wall) {
  19.           this.wall = wall;
  20.      }
  22.      public String getRoof() {
  23.           return roof;
  24.      }
  26.      public void setRoof(String roof) {
  27.           this.roof = roof;
  28.      }
  30.      @Override
  31.      public String toString() {
  32.           return "House{" +
  33.                   "base='" + base + '\'' +
  34.                   ", wall='" + wall + '\'' +
  35.                   ", roof='" + roof + '\'' +
  36.                   '}';
  37.      }
  38. }
  1. //抽象的房子制造者（只会制造房子的单个步骤）
  2. public abstract class HouseBuilder {
  3.     House house = new House();
  5.     public abstract void buildBase();
  6.     public abstract void buildWall();
  7.     public abstract void buildRoof();
  9.     public House getHouse(){
  10.         return house;
  11.     }
  12. }
  14. //普通房子建造者（继承抽象制造者）
  15. public class CommHouserBuilder extends HouseBuilder{
  16.     @Override
  17.     public void buildBase() {
  18.         house.setBase("5米的地基");
  19.         System.out.println("建造了5米的地基");
  20.     }
  22.     @Override
  23.     public void buildWall() {
  24.         house.setWall("5厘米的墙");
  25.         System.out.println("砌好了5厘米的墙");
  26.     }
  28.     @Override
  29.     public void buildRoof() {
  30.         house.setRoof("普通屋顶");
  31.         System.out.println("盖上了普通屋顶");
  32.     }
  33. }
  35. //高端房子建造者（继承抽象制造者）
  36. public class HighHouseBuilder extends HouseBuilder{
  37.     @Override
  38.     public void buildBase() {
  39.         house.setBase("50米的地基");
  40.         System.out.println("建造了50米的地基");
  41.     }
  43.     @Override
  44.     public void buildWall() {
  45.         house.setWall("20厘米的墙");
  46.         System.out.println("砌好了20厘米的墙");
  47.     }
  49.     @Override
  50.     public void buildRoof() {
  51.         house.setRoof("高级屋顶");
  52.         System.out.println("盖上了高级屋顶");
  53.     }
  54. }
  1. //指挥者，指挥建造者建造对应的房子
  2. //相当于建造者只会建房的每一个步骤，但是建造房子的步骤不知道，指挥者就指挥建造者按照固定步骤建房
  3. public class Director {
  4.     HouseBuilder houseBuilder;
  6.     public Director(HouseBuilder houseBuilder) {
  7.         this.houseBuilder = houseBuilder;
  8.     }
  10.     public void setHouseBuilder(HouseBuilder houseBuilder) {
  11.         this.houseBuilder = houseBuilder;
  12.     }
  14.     public House directorBuildHouse(){
  15.         houseBuilder.buildBase();
  16.         houseBuilder.buildWall();
  17.         houseBuilder.buildRoof();
  18.         return houseBuilder.getHouse();
  19.     }
  20. }
  1. //客户联系指挥者需要房子，指挥者指挥建造者建房子
  3. public class Client {
  4.     public static void main(String[] args) {
  5.         //建造普通房子
  6.         HouseBuilder commHB = new CommHouserBuilder();
  7.         Director director = new Director(commHB);
  8.         House chouse = director.directorBuildHouse();
  9.         System.out.println(chouse);
  10.         System.out.println("-----------------------------------------------------");
  11.         //建造高级房子
  12.         director.setHouseBuilder(new HighHouseBuilder());
  13.         House hhouse = director.directorBuildHouse();
  14.         System.out.println(hhouse);
  16.     }
  17. }

测试结果：image-20200927191012995.png

建造者模式的注意事项和细节

  1. 客户端(使用程序)不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象
  2. 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象
  3. 可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程
  4. 增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合 开闭原则
  5. 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
  6. 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化， 导致系统变得很庞大，因此在这种情况下，要考虑是否选择建造者模式.
  7. 抽象工厂模式VS建造者模式

抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式不需要关心构建过程，只关心什么产品由什么工厂生产即可。而建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品

个人总结
工厂模式制作的对象不需要固定的流程步骤；

建造者建造的对象除了原料还需固定的制作流程，而流程的指挥需要有指挥者完成；