建造者模式的理解

定义:将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

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

例子2：假设造房简化为如下步骤:(1）地基(2）钢筋工程(3）铺电线(4）粉刷;i“如果”要盖一座房子，首先要找一个建筑公司或工程承包商（指挥者)。承包商指挥工人(具体建造者）过来造房子(产品)，最后验收。

//抽象的建造者
public abstract class Builder {
    abstract void buildA(); //1地基
    abstract void buildB();//2钢筋工程

    //得到具体的产品
    abstract  Product getproduct();
}

//产品
public class Product {
    private String buildA;
    private String buildB;
   //getset省略
}

//具体的建造者
public class Worker extends  Builder{
    private Product product;

    public Worker(){
        //这里注意传参数进来赋值给产品而是由具体的建造者创建
        //this.product =product;
        product =  new Product();
    }
    @Override
    void buildA() {
        product.setBuildA("地基");
        System.out.println("地基");
    }
    @Override
    void buildB() {
        product.setBuildA("钢筋工程");
        System.out.println("钢筋工程");
    }
    @Override
    Product getproduct() {
        return product;
    }
}

///指挥:核心 负责指挥构建一个工程，工程如何构建，由它决定
public class Director {
    public Product build(Builder builder){
        //指挥工人按照顺序建房子 可以控制顺序
        builder.buildB();
        builder.buildA();

        return builder.getproduct();
    }
}

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

    }
}

有的时候不需要总指挥，把执行顺序交到用户手上，下面是kfc点餐的一个例子

//抽象的建造者
public abstract class Builder {
    abstract Builder buildA(String msg); //可乐
    abstract Builder buildB(String msg);//薯条

    //得到具体的产品
    abstract Product getproduct();
}

//产品 套餐
public class Product {
    //默认套餐
    private String buildA = "可乐";
    private String buildB = "薯条";
    //getset省略
}

//具体的建造者
public class Worker extends Builder {
    private Product product;

    public Worker(){
        //这里注意传参数进来赋值给产品而是由具体的建造者创建
        //this.product =product;
        product =  new Product();
    }
    @Override
    Builder buildA(String msg) {
        product.setBuildA(msg);
        return this;
    }
    @Override
    Builder buildB(String msg) {
        product.setBuildB(msg);
        return this;
    }
    @Override
    Product getproduct() {
        return product;
    }
}

public class Test {
    public static void main(String[] args) {
        //服务员
        Worker worker = new Worker();
        //链式编程
        //Product getproduct = worker.getproduct();
        Product getproduct = worker.buildA("全家桶").buildB("鸡腿").getproduct();
        System.out.println(getproduct);
    }
}

应用场景：1，需要生成的产品对象有复杂的内部结构，这些产品对象具备共性;2，隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品,3，适合于一个具有较多的零件(属性)的产品（对象）的创建过程。

建造者与抽象工厂模式的比较:1，与抽象工厂模式相比，建造者模式返回一个组装好的完整产品，而抽象工厂模式返回一系列相关的产品，这些产品位于不同的产品等级结构，构成了一个产品族。2，在抽象工厂模式中，客户端实例化工厂类，然后调用工厂方法获取所需产品对象，而在建造者模式中，客户端可以不直接调用建造者的相关方法，而是通过指挥者类来指导如何生成对象，包括对象的组装过程和建造步骤，它侧重于一步步构造一个复杂对象，返回一个完整的对象。3，如果将抽象工厂模式看成汽车配件生产工厂，生产一个产品族的产品，那么建造者模式就是一个汽车组装工厂，通过对部件的组装可以返回一辆完整的汽车!

总结：优点：1，产品的建造和表示分离，实现了解耦。使用建造者模式可以使客户端不必知道产品内部组成的细节。2，将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰。3，具体的建造者类之间是相互独立的，这有利于系统的扩展。增加新的具体建造者无需修改原有类库的代码，符合“开闭原则“。 缺点 ：1，建造者模式所创建的产品一般具有较多的共同点，其组成部分相似;如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。2，如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。