设计模式 建造者模式

基本概念

建造者模式也是创建形模式的一种(即避免了创建对象时使用new)

简单例子

我们模拟一个创建房子的过程 假设需要4个步骤才能创建好房子 地基,钢筋工程,铺电线,粉刷

定义产品实体类

模拟假设执行了4个步骤就给定义的4个属性赋值

@Data
public class Product {
    String stepA;
    String stepB;
    String stepC;
    String stepD;
}

定义Build抽象类

定义Build抽象类 包含了我们需要的4个步骤以及返回产品的抽象方法

public abstract class Builder {
    //假设建房要4个步骤
    abstract void stepA();//地基
    abstract void stepB();//钢筋工程
    abstract void stepC();//铺电线
    abstract void stepD();//粉刷
    //完工 得到产品
    abstract Product getProduct();
}

定义Worker具体实现类

定义了抽象类就需要去写实现类 我们写一个Worker去具体实现内部逻辑

//具体的建筑者 工人
public class Worker extends Builder {
    private Product product;
    //注意这里的构造方法
    public Worker() {
        product=new Product();
    }

    void stepA() {
        product.setStepA("地基");
        System.out.println("地基");
    }

    void stepB() {
        product.setStepB("钢筋工程");
        System.out.println("钢筋工程");
    }

    void stepC() {
        product.setStepC("铺电线");
        System.out.println("铺电线");
    }

    void stepD() {
        product.setStepD("粉刷");
        System.out.println("粉刷");
    }

    Product getProduct() {
        return product;
    }
}

定义指挥者 指挥工人如何去创建(核心思想)

注意参数是抽象类 Builder
这样我们就可以根据具体传进来的工人类去执行对应的方法

public class Director {
    //指挥工人按照一种顺序工作
    public Product getProduct(Builder builder){
        builder.stepA();
        builder.stepB();
        builder.stepC();
        builder.stepD();
        return builder.getProduct();
    }
}

测试使用

public class Test {
    public static void main(String[] args) {
        //指挥
        Director director=new Director();
        //指挥 具体的工人
        Product product = director.getProduct(new Worker());
        System.out.println(product);
    }
}

这样写完后 假设我们想调换构造顺序就很简单了
只需要在指挥类换下运行顺序即可

小总结

另外一种形态 不需要指挥者形态

我们来实现上面那个图中麦当劳的情形

首先定义实体类 并赋初值

@Data
public class Product {
    private String BuildA = "汉堡";
    private String BuildB = "薯条";
    private String BuildC = "可乐";
    private String BuildD = "甜点";
}

同样的去定义抽象build类 这里返回类型为Builder主要是为了后面的链式编程

public abstract class Builder {
    abstract Builder buildA(String msg);//汉堡
    abstract Builder buildB(String msg);//薯条
    abstract Builder buildC(String msg);//可乐
    abstract Builder buildD(String msg);//甜点
    abstract Product getProduct();
}

定义worker类去实现

public class Worker extends Builder{
    private Product product;

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

    Builder buildA(String msg) {
        product.setBuildA(msg);
        return this;
    }

    Builder buildB(String msg) {
        product.setBuildB(msg);
        return this;
    }

    Builder buildC(String msg) {
        product.setBuildC(msg);
        return this;
    }

    Builder buildD(String msg) {
        product.setBuildD(msg);
        return this;
    }

    Product getProduct() {
        return product;
    }
}

测试使用:

public class Test {
    public static void main(String[] args) {
        Worker worker=new Worker();
        Product product=worker
                .buildA("双层牛肉堡")
                .buildC("雪碧")
                .getProduct();
        System.out.println(product);
    }
}

讲指挥者的功能交给用户去自定义操作 这就是另外一个形态的思想