设计模式(3)——建造者模式

建造者模式

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

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

主要作用：在用户不知道对象的建造过程和细节的情况下可以直接创建复杂的对象

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

方式一

Product

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 + '\'' +
                '}';
    }
}

Builder

//计划【过程+产品】
public abstract class Builder {
    public abstract void builderA();//地基
    public abstract void builderB();//钢筋水泥
    public abstract void builderC();//建筑工程
    public abstract void builderD();//粉刷

    public abstract Product getProduct();
}

ConBuilder

//工人【执行过程+获得产品】
public class ConBuilder extends Builder {
    private Product product;

    public ConBuilder() {
        product = new Product();//此产品是由工人生产的
    }

    @Override
    public void builderA() {
        product.setBuildA("地基");
        System.out.println("地基");
    }

    @Override
    public void builderB() {
        product.setBuildB("钢筋水泥");
        System.out.println("钢筋水泥");
    }

    @Override
    public void builderC() {
        product.setBuildC("建筑工程");
        System.out.println("建筑工程");
    }

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

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

}

Director

//领导
public class Director {
    public Product getProduct(Builder builder) {
        builder.builderA();
        builder.builderB();
        builder.builderC();
        builder.builderD();

        return builder.getProduct();
    }

}

Test

public class Test {
    public static void main(String[] args) {
        Director director = new Director();
        Product product = director.getProduct(new ConBuilder());
        System.out.println(product.toString());
    }
}

**方式二 ** 不需要指挥者

Product

public class Product {
    private String snack1 = "汉堡包";
    private String snack2 = "蛋挞";
    private String snack3 = "鸡翅";
    private String snack4 = "薯条";

    public String getSnack1() {
        return snack1;
    }

    public void setSnack1(String snack1) {
        this.snack1 = snack1;
    }

    public String getSnack2() {
        return snack2;
    }

    public void setSnack2(String snack2) {
        this.snack2 = snack2;
    }

    public String getSnack3() {
        return snack3;
    }

    public void setSnack3(String snack3) {
        this.snack3 = snack3;
    }

    public String getSnack4() {
        return snack4;
    }

    public void setSnack4(String snack4) {
        this.snack4 = snack4;
    }

    @Override
    public String toString() {
        return "Product{" +
                "snack1='" + snack1 + '\'' +
                ", snack2='" + snack2 + '\'' +
                ", snack3='" + snack3 + '\'' +
                ", snack4='" + snack4 + '\'' +
                '}';
    }
}

Builder

public abstract class Builder {
    abstract Builder builder1(String msg);//可以根据传入的来选择通过生产自己想要获得的
    abstract Builder builder2(String msg);
    abstract Builder builder3(String msg);
    abstract Builder builder4(String msg);

    abstract Product getProduct();
}

ConBuilder

public class ConBuilder extends Builder {

    private Product product;

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

    @Override
    Builder builder1(String msg) {
        product.setSnack1(msg);
        return this;
    }

    @Override
    Builder builder2(String msg) {
        product.setSnack2(msg);
        return this;
    }

    @Override
    Builder builder3(String msg) {
        product.setSnack3(msg);
        return this;
    }

    @Override
    Builder builder4(String msg) {
        product.setSnack4(msg);
        return this;
    }

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

Test

public class Test {
    public static void main(String[] args) {
        Builder conBuilder = new ConBuilder();
//        Product product = conBuilder.getProduct();//默认的套餐产品
        Product product = conBuilder.builder3("可乐").getProduct();//可自行更改套餐，实现链式编程

        System.out.println(product.toString());
    }
}

优点：-

• 产品的建造和表示分离，实现了解耦。建造者模式可以使客户端不必知道产品内部的组成细节
• 将复制产品创建步骤分解在不同的方法中，使得创建过程更加清晰
• 具体的建造者类之间使相互独立的，这有利于系统的扩展。增加新的具体建造者无需修改原有类库的代码，符合“开闭原则”

缺点：

• 建造者模式所创建的产品一般具有较多共同点，其组成部分相似；如果产品之间差异较大，则不适合使用建造者模式，因此使用范围受到一定限制
• 如果产品内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大

应用场景：

• 需要生成的产品对象有复杂的内部结构，这些产品对象具备共性
• 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品
• 适合于一个具有较多的零件（属性）的产品（对象）的创建过程