设计模式之建造者模式

设计模式之建造模式

  1. 实例：建房子

    1. 建房子的流程：可以大致分为以下几个步骤：打地基、砌墙、封顶

    2. 房子的种类也有各式各样的，有普通房子、高楼、别墅，虽然建造步骤都一样，但是要求是不同的

  2. 传统方式

    1. 代码

      //首先可以创建一个抽象类或者接口
      public abstract class AbstractHouse{
          //打地基
          public abstract void buildBasic();
          
          //砌墙
          public abstract void buildWall();
          
          //封顶
          public abstract void roofed();
          
          //注意上面三个方法是有调用顺序的
          public  void bulid(){
              buildBasic();
              buildWall();
              roofed();
          }
      }
      ​
      //创建一个建普通房子类实现上面的抽象类
      public class CommonHouse extends AbstractHouse{
          @Override
          public abstract void buildBasic(){
              System.out.println("普通房子打地基");
          }
          @Override
          public abstract void buildWall(){
              System.out.println("普通房子砌墙");
          }
          @Override
          public abstract void roofed(){
              System.out.println("普通房子封顶");
          }
          
      }
      ​
      ​
      //客户端
      public class Client{
          public static void main(String[] args){
              CommonHouse ch = new CommonHouse();
              ch.build();
          }
      }

       

    2. 优缺点

      1. 优点是比较好理解，简单易操作

      2. 缺点：设计的程序结果，过于简单，没有设计缓存层对象，程序的扩展和维护不好，也就是说，这种设计方案，把产品(房子)和创建产品的过程(建房子的流程)封装在一起，耦合性增强了

      3. 解决方案：将产品和创建产品的过程解耦=====》创建者模式

    3. 类图

      1. 　　

  3. 建造者模式

    1. 建造者模式基本介绍

      1. 建造者模式(Builder Pattern)又叫生成器模式，是一种对象构造模式。它可以将复杂对象的建造过程抽象出来(抽象类别）,使得这个抽象过程的不同实现方法可以构造出不同表现(属性)的对象

      2. 建造者模式是一步一步创建一个复杂的对象，它允许用户通通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节

    2. 建造者模式的角色

      1. 可以分为以下四种角色

        1. product(产品角色)：一个具体的产品对象

        2. Bulider(抽象建造者)：创建一个product对象的各个部件指定的接口或者抽象类

        3. ConcreteBuilder(具体构建者)：实现结构，构建和装配各个部件

        4. Director(指挥者)：构建一个使用Bulider接口的对象。它主要是用于创建一个复杂的对象。他主要有两个作用，1.隔离了客户与对象的生产过程。2.负责控制产品对象的生产过程

      2. 四种角色之间的关系

         

      3. 通过建造者模式：建造房子实例

        1. 代码

          //产品===>product
          public class House{
              private String basic;
              private String wall;
              private String roofed;
              //get和set方法
          }
          //抽象建造者
          public abstract class HouseBuilder{
              //将House组合进来
              protected House  house = new House();
              //打地基
              public abstract void buildBasic();
              //砌墙
              public abstract void buildWall();
              //封顶
              public abstract void roofed();
              
              //建造房子有流程
              public House build(){
                  return house;
              }
          }
          ​
          //具体建造者(普通房子)
          public class CommonHouse extends HouseBuilder{
              @Override
              public abstract void buildBasic(){
                  System.out.println("普通房子打地基深5米");
              }
              @Override
              public abstract void buildWall(){
                  System.out.println("普通房子砌墙高3米");
              }
              @Override
              public abstract void roofed(){
                  System.out.println("普通房子封顶");
              }
              
          }
          //具体构造者：别墅、高楼感兴趣自己编写
          //指挥者
          public class HouseDirector{
              HouseBuilder houseBuilder = null;
              //传houseBuilder对象的方式1：构造器
              public HouseDirector(HouseBuilder houseBuilder){
                  this.houseBuilder=houseBuilder;
              }
              //传houseBuilder对象的方式2:setter方法
              public void setHouseBuilder(HouseBuilder houseBuilder){
                  this.houseBuilder=houseBuilder;
              }
              //如何处理建造房子的流程，交给指挥者
              public House constructHouse(){
                  //打地基
                  houseBuilder.buildBasic();
                  //砌墙
                  houseBuilder.builderWall();
                  //封顶
                  houseBuilder.roofed();
                  return houseBuilder.buildHouse();
              }
          }
          ​
          //客户端
          public class Client{
              public static void main(String[] aegs){
                  //建普通房子
                  CommonHouse ch = new CommonHouse();
                  //准备创建房子的指挥者
                  HouseDirector hd = new HouseDirector(ch);
                  House house = hd.constructHouse();
              }
          }

           

        2. 类图

        3. 建造者在JDk中的应用

          1. java.lang.StringBuilder中使用到了建造者模式

          2. 源码中建造者模式角色分析

            1. Appendable接口定义了多个append()（抽象方法）方法，即该接口为抽象建造者，因为定义了抽象方法

            2. AbstactStringBuilder抽象类实现了Appendable接口的方法，因此这个类是具体建造者，只是不能实例化

            3. StringBuilder继承了AbstactStringBuilder，即充当了指挥者有充当了具体的建造者，建造方法的实现是由AbstactStringBuilder完成的，而StringBuild只是继承了AbstactStringBuilder

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

          1. 客户端不需要知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象

          2. 每一个建造者都相对独立，而与其他具体的建造者无关，因此可以很方便的替换具体建造者或者增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象

          3. 可以更加精细非控制产品的创建过程。将负责产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便的使用程序来控制创建过程

          4. 增加新的具体建造者不需要修改原有的类库的代码，指挥者类针对抽象建造者编程。系统扩展更方便，符合开闭原则

          5. 建造者所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合是哟领建造者模式。因此其范围受到了一定的约束

          6. 如果产品内部变化复杂，可能会导致需要定义很多的具体创建者类类实现这种变化，导致系统变得很庞大，因此在这种情况下，要考虑是否选择创建者模式

          7. 抽象工厂和创建者模式的比较

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

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/juddy/p/14967915.html