建造者模式-遇见狂神说

创建型模式：（省去new对象，帮助我们更好的创建对象）
单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式
结构型模式：
设配器模式、桥接模式、装饰模式、组合模式、、外观模式、亨元模式、代理模式
行为型模式：
模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式

建造者模式
建造者模式也属于创建型模式，他提供了一种创建对象的最佳方式。

定义：将一个复杂对象的构建与他的表示分离，使同样的构建过程可以创建不同的表示
主要作用：在用户不知道 对象的建造和细节 的情况下就可以直接创建复杂的对象

用户只需要给出指定复杂对象的类型和内容，建造者模式负责按顺序创建复杂对象（把内部的建造过程和细节隐藏起来）

例子：
工厂（建造者模式）：负责制造汽车（组装过程和细节在工厂内）
汽车购买者（用户）：你只需要说出你需要的型号（对象的类型和内容），然后直接购买就可以使用了（不要知道汽车是怎么组装的（车轮、车门、发动机、方向盘等等））

代码

抽象构建者 Builder

//抽象的建造者 ： 不负责建造 只是负责定义一些方法与接口
public abstract class Builder {

    abstract void bulidA(); //地基
    abstract void bulidB(); //钢筋工程
    abstract void bulidC(); //铺电线
    abstract void bulidD(); //粉刷

    //做完上面的步骤之后会生成一个产品
    abstract Product getproduct();

}

产品Produce

// 产品  做完地基 钢筋水泥 电线 粉刷后生成的产品
public class Product {

    private String buildA;
    private String buildB;
    private String buildC;
    private String buildD;

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

    public String getBuildD() {
        return buildD;
    }

    public void setBuildD(String buildD) {
        this.buildD = buildD;
    }

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

具体的建造者：工人 Worker

//具体的建造者：工人
public class Worker extends Builder{

    //工人需要完成一个产品
    private Product product;

    //产品是由工人创建的（而不是通过构造器传入）
    public Worker() {
        product = new Product();
    }

    @Override
    void bulidA() {
        // 创建产品  Product实现了Builder（抽象创建者）的抽象方法
        product.setBuildA("地基");
        System.out.println("地基");
    }

    @Override
    void bulidB() {
        product.setBuildB("钢筋工程");
        System.out.println("钢筋工程");
    }

    @Override
    void bulidC() {
        product.setBuildC("铺电线");
        System.out.println("铺电线");
    }

    @Override
    void bulidD() {
        product.setBuildD("粉刷");
        System.out.println("粉刷");
    }

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

指挥 ：核心 Director

//指挥： 核心 负责指挥构建一个工程 工程如何构建由他决定
public class Director {

    //指挥者负责指挥他安装顺序生成一个产品（核心构建顺序）
    //指挥一个抽象建造者（builder可能传入不同的工人）
    public Product build(Builder builder){
        builder.bulidA();
        builder.bulidB();
        builder.bulidC();
        builder.bulidD();

        return builder.getproduct();
    }
}

测试类 TestBuilder

public class TestBuilder {
    public static void main(String[] args) {
        //指挥
        Director director = new Director();
        //指挥具体的工人完成产品
        Product build = director.build(new Worker());
        System.out.println(build.toString());
    }
}

结果

指挥者可以控制调用，具体的工人不需要改变


第一种核心是指挥者，指挥者最终交给客户。第二种方式不需要指挥者

建造者：Builder

//建造者
public abstract class Builder {

    //为了方便用户传入需求 定义一些参数。若不赋值参数 就是默认Produce的套餐
    abstract Builder bulidA(String msg); //汉堡
    abstract Builder bulidB(String msg); //可乐
    abstract Builder bulidC(String msg); //薯条
    abstract Builder bulidD(String msg); //甜点

    //固定 建造者模式就是为了建造产品 只是建造这些产品的时候可能出现一些默认值
    abstract Product getProduct();
}

产品 ： Produce

//产品： 具体的套餐
public class Product {

    //固定套餐
    private String buildA="汉堡";
    private String buildB="可乐";
    private String buildC="薯条";
    private String buildD="甜点";

    //自己选择套餐
    public void setBuildA(String buildA) {
        this.buildA = buildA;
    }

    public void setBuildB(String buildB) {
        this.buildB = buildB;
    }

    public void setBuildC(String buildC) {
        this.buildC = buildC;
    }

    public void setBuildD(String buildD) {
        this.buildD = buildD;
    }

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

具体建造者： Worker

//具体建造者
public class Worker extends Builder{

    Product product;

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

    //work.buildA 返回的是Builder 可以继续调用build* .getproduct
    @Override
    Builder bulidA(String msg) {
        product.setBuildA(msg);
        return this;
    }

    @Override
    Builder bulidB(String msg) {
        product.setBuildB(msg);
        return this;
    }

    @Override
    Builder bulidC(String msg) {
        product.setBuildC(msg);
        return this;
    }

    @Override
    Builder bulidD(String msg) {
        product.setBuildD(msg);
        return this;
    }

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

测试一：默认情况

public class BuilderChainTest {
    public static void main(String[] args) {
        //服务员
        Worker worker = new Worker();
        Product product = worker.getProduct();
        System.out.println(product.toString());
    }
}

测试二：链式编程 自定义内容

public class BuilderChainTest {
    public static void main(String[] args) {
        //服务员
        Worker worker = new Worker();
        //链式编程：在原来的基础上可以自由组合了，如果不组合也有默认的套餐
        //work.buildA 返回的是Builder 可以继续调用build* 然后 .getproduct
        Product product = worker.bulidA("三明治").bulidB("雪碧")
                            .getProduct();
        System.out.println(product.toString());
    }
}