设计模式之建造者模式

设计模式之建造模式

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