java设计模式-08建造者模式

定义

1. 为了分离对象的属性与创建过程
2. 又被称呼为生成器模式，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
3. 使用多个简单的对象一步一步构建成一个复杂的对象，有点像造房子一样一步步从地基做起到万丈高楼。
4. 主要作用：在用户不知道对象的建造过程和细节的情况下就可以直接创建复杂的对象。
5. 如何使用：用户只需要给出指定复杂对象的类型和内容，建造者模式负责按顺序创建复杂对象（把内部的建造过程和细节隐藏起来）
6. 注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序，一般用来创建更为复杂的对象

四大角色

1. 抽象建造者（builder）：描述具体建造者的公共接口，一般用来定义建造细节的方法，并不涉及具体的对象部件的创建。
2. 具体建造者（ConcreteBuilder）：描述具体建造者，并实现抽象建造者公共接口。
3. 指挥者（Director）：调用具体建造者来创建复杂对象（产品）的各个部分，并按照一定顺序（流程）来建造复杂对象。
4. 产品（Product）：描述一个由一系列部件组成较为复杂的对象。

通过Client、Director、Builder和Product形成的建造者模式

举个例子:
1 造房简化为如下步骤：（1）地基（2）墙壁（3）房顶

步骤如下

1. 创建抽象建造者定义造房步骤
2. 创建工人具体实现造房步骤
3. 创建承包商指挥工人施工
4. 验收，检查是否建造完成

代码

package com.example.demo;

public class test2 {
   public static void main(String[] args) {
       Director director = new Director();
       Product product = director.concreteBuilder(new ConcreteBuilder());
       System.out.println(product.toString());

   }
}

//建造者抽象类
abstract class Builder {
   //地基
   abstract void buildA();

   //墙壁
   abstract void buildB();

   //屋顶
   abstract void buildC();

   //完工-获取产品
   abstract Product getProduct();

}

class Product {
   private String buildA;
   private String buildB;
   private String buildC;

   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;
   }

   @Override
   public String toString() {
       return "Product{" +
               "buildA='" + buildA + '\'' +
               ", buildB='" + buildB + '\'' +
               ", buildC='" + buildC + '\'' +
               '}';
   }
}

//建造者实现类
class ConcreteBuilder extends Builder {
   private Product product;

   public ConcreteBuilder() {
       product = new Product();
   }

   @Override
   void buildA() {
       product.setBuildA("地基");
   }

   @Override
   void buildB() {
       product.setBuildB("墙壁");

   }

   @Override
   void buildC() {
       product.setBuildC("屋顶");
   }

   @Override
   Product getProduct() {
       return product;
   }
}

/**
* 建造者
*/
class Director {
   public Product concreteBuilder(Builder builder) {
       builder.buildA();
       builder.buildB();
       builder.buildC();
       return builder.getProduct();
   }
}

通过静态内部类方式实现零件无序装配话构造

• 这种方式使用更加灵活，更符合定义。
• 内部有复杂对象的默认实现，使用时可以根据用户需求自由定义更改内容，并且无需改变具体的构造方式。就可以生产出不同复杂产品

主要是三个角色

• 抽象建造者、具体建造者、产品
• 少了指挥者，主要是因为第二种方式把指挥者交给用户来操作，使得产品的创建更加简单灵活。
• 用户就可以随意搭配了

代码

public class test2 {
    public static void main(String[] args) {
        ConcreteBuilder director = new ConcreteBuilder();
        Product product = director.getProduct();
        director.buildA("地基");
        director.buildB("墙壁");
        director.buildC("楼顶");
        System.out.println(product.toString());
    }
}

//建造者抽象类
abstract class Builder {
    //地基
    abstract Builder buildA(String mes);

    //墙壁
    abstract Builder buildB(String mes);

    //屋顶
    abstract Builder buildC(String mes);

    //完工-获取产品
    abstract Product getProduct();

}

class Product {
    private String buildA;
    private String buildB;
    private String buildC;

    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;
    }

    @Override
    public String toString() {
        return "Product{" +
                "buildA='" + buildA + '\'' +
                ", buildB='" + buildB + '\'' +
                ", buildC='" + buildC + '\'' +
                '}';
    }
}

//建造者实现类
class ConcreteBuilder extends Builder {
    private Product product;

    public ConcreteBuilder() {
        product = new Product();
    }

    @Override
    Builder buildA(String mes) {
        product.setBuildA(mes);
        return this;

    }

    @Override
    Builder buildB(String mes) {
        product.setBuildB(mes);
        return this;
    }

    @Override
    Builder buildC(String mes) {
        product.setBuildC(mes);
        return this;
    }

    @Override
    Product getProduct() {
        return product;

    }
}

优点：

1. 产品的建造和表示分离，实现了解耦。
2. 将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰
3. 增加新的具体建造者无需修改原有类库的代码，易于拓展，符合“开闭原则“。

缺点：

1. 产品必须有共同点，限制了使用范围。
2. 如内部变化复杂，会有很多的建造类，难以维护。