建造者模式介绍

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

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

**主要作用：**用户不需要知道，对象的的建造过程和细节，就能创建复杂的对象

例子：

​ 1.工厂（建造者模式）：负责造汽车（组装过程和细节在工厂内）

​ 2.购买者（用户）：只需要说出型号（对象的类型和内容），就能直接购买（不用知道汽车怎么组装的）

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

代码案例实现

//1.-----------抽象的建造者：定义产品的建造方法----------
public abstract class Builder {
    abstract void buildA(); //步骤一
    abstract void buildB(); //步骤二
    //建造完成，得到产品：
    abstract Product getProduct();
}

//2.------- 定义产品，产品与建造者无必然联系 ---------
public class Product {
    private String buildA;  //步骤一搞定
    private String buildB;  //步骤二搞定

    //get set 方法
    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; }
    //toString方法
    @Override
    public String toString() {
        return "Product{" + "buildA='" + buildA + '\'' + ", buildB='" + buildB + '\'' + '}';
    }
}

/*
3.----------工人继承Builder类，实现方法-------
	不同的工人，可以按照构建者模式，生产不同规格的产品
*/
public class Worker extends Builder {
    private Product product;    //产品

    /*--- 这一步很重要，工人负责创建产品，而不是外部传进来 --*/
    public Worker() {
        this.product = new Product();
    }
    //执行第一步
    @Override
    void buildA() {
        product.setBuildA("步骤A");
        System.out.println("步骤A");
    }
    //执行第二步
    @Override
    void buildB() {
        product.setBuildB("步骤B");
        System.out.println("步骤B");
    }
    //返回完整产品
    @Override
    Product getProduct() {
        return product;
    }
}
//4.----------指挥者，指挥工人生产产品
public class Director {
    //****指挥工人，按照顺序构建产品****
    public Product build(Builder builder){
    	//*****可以控制顺序*******
        builder.buildB();
        builder.buildA();
        return builder.getProduct();
    }
}

//5.--------测试：按照指挥者指定的顺序，得到产品--------
public static void main(String[] args) {
    Director director = new Director();
    Product product = director.build(new Worker());
    System.out.println(product);
}

• 上面是Builder模式的常规用法，指挥类Director在构造者模式中作用很大：指挥具体构建者（Worker）如何构建产品，控制先后次序，并返回完整的产品类（Product）

代码案例实现二

• 通过静态内部类方式，实现零件无序装配构造，这种方式更灵活、更符合定义。内部有复杂对象的默认实现，使用时也可自定义更改内容，并且无需改变构造方式。

• 比如：饭店的套餐，服务员（具体构造者），可以默认几种菜品（零件）组成套餐（产品），客户（使用者）也可要求更换其中的菜品（零件）

• 比第一种少了指挥者，客户就是指挥者

//1.------------ 产品，属性有默认值 ------------
public class Product {
    private String foodA = "小龙虾";
    private String foodB = "大白菜";
    //get set 方法
    public String getFoodA() { return foodA; }
    public void setFoodA(String foodA) { this.foodA = foodA; }
    public String getFoodB() { return foodB; }
    public void setFoodB(String foodB) { this.foodB = foodB; }
    @Override
    public String toString() {
        return "Product{" + "foodA='" + foodA + '\'' + ", foodB='" + foodB + '\'' + '}';
    }
}

//2.---------- 抽象构造者，定义生产产品有哪些步骤----------
public abstract class Builder {
    //构造方法
    abstract Builder buildA(String msg);
    abstract Builder buildB(String msg);
    //返回产品
    abstract Product getProduct();
}

//3.---------- 具体构造者（服务员）----------
public class Worker extends Builder {
    private Product product;
    //产品在构造器中创建，而不是外部传进来
    public Worker() {
        product = new Product();
    }
    @Override
    Builder buildA(String msg) {
        product.setFoodA(msg);
        return this;    //返回当前对象
    }
    @Override
    Builder buildB(String msg) {
        product.setFoodA(msg);
        return this;    //返回当前对象
    }
    @Override
    Product getProduct() {
        return product;
    }
}
//4.---------- 测试：----------
public static void main(String[] args) {
    //服务员
    Builder worker = new Worker();
    //输出默认产品
    System.out.println(worker.getProduct());
    //链式编程（执行方法之后，依然返回当前对象：worker）
    Product product = worker.buildA("大豆角").buildB("冰淇淋").getProduct();
    System.out.println(product);
}
输出结果：
    Product{foodA='小龙虾', foodB='大白菜'}
	Product{foodA='大豆角', foodB='冰淇淋'}

优点

• 产品的建造和表示分离，实现了解耦。客户端不用知道具体细节
• 将负责的产品创建步骤、分节在不同的方法中，使创建过程更清晰
• 符合“开闭原则”，不同的建造者之间相互独立，有利于系统的扩展

缺点

• 适用范围受限：创建的产品具有较多共同点，组成部分相似；如果产品之间差异性很大，则不适用建造者模式。
• 如果产品的内部变化复杂，可能导致需要定义很多具体建造者（实现类）来实现这种变化，导致系统很庞大

应用场景

• 产品对象 内部结构复杂、具备共性
• 隔离复杂对象的创建和使用，使相同的创建过程可以创建不同的产品
• 适合创建有较多属性的对象

与抽象工厂比较