创建型模式——建造者模式

创建型模式最后一种：建造者模式，它是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

用户不用知道对象的建造过程和细节，可以直接创建复杂的对象。

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

我们先来看一下建造者模式的角色：

• 抽象建造者类（Builder）：这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的部件对象的创建，而是由具体建造者类来实现。（这里的接口并不是我们通常在Java里面定义的接口，而是指的是一种规范，既可以是Java里面的接口，又可以是抽象类）
• 具体建造者类（ConcreteBuilder）：实现Builder接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实例。
• 产品类（Product）：要创建的复杂对象
• 指挥者类（Director）：调用具体建造者来创建复杂对象的各个部分，在指挥者中不涉及具体产品的信息，它只负责保证对象各个部分完整创建或按某种顺序创建。

接下来我们用代码实现

首先是创建产品类，这里我们用建造一个自行车来演示：

package pattern.builder.demo1;

/**
 * 自行车产品对象
 * 
 * @author ***
 * @create 2022-05-18 20:34
 */
public class Bike {
    private String frame;//车架
    private String seat;//车座

    public Bike() {
    }

    public Bike(String frame, String seat) {
        this.frame = frame;
        this.seat = seat;
    }

    public String getFrame() {
        return frame;
    }

    public void setFrame(String frame) {
        this.frame = frame;
    }

    public String getSeat() {
        return seat;
    }

    public void setSeat(String seat) {
        this.seat = seat;
    }
}

接着创建抽象建造者类，即Builder

package pattern.builder.demo1;

/**
 * 抽象建造者类
 * 
 * @author hxk
 * @create 2022-05-18 20:36
 */
abstract class Builder {
    Bike bike = new Bike();
    public abstract void builderFrame();

    public abstract void builderSeat();

    public abstract Bike createBike();
}

然后，我们就要创建具体的建造者类：

第一个：摩拜单车（MoBai）:

package pattern.builder.demo1;

/**
 * 具体的构建者，用来构建摩拜单车对象
 * 
 * @author ***
 * @create 2022-05-18 20:38
 */
public class Mobai extends Builder{
    @Override
    public void builderFrame() {
        bike.setFrame("铝合金");
    }

    @Override
    public void builderSeat() {
        bike.setSeat("橡胶");
    }

    @Override
    public Bike createBike() {
        return bike;
    }

}

第二个：哈喽单车（Hello）:

package pattern.builder.demo1;

/**
 * 具体的构建者，用来构建哈喽单车对象
 * 
 * @author ***
 * @create 2022-05-18 20:40
 */
public class Hello extends Builder{
    @Override
    public void builderFrame() {
        bike.setFrame("碳钎维");
    }

    @Override
    public void builderSeat() {
        bike.setSeat("真皮");
    }

    @Override
    public Bike createBike() {
        return bike;
    }
}

最后是指挥者类Director，对对象构建进行组装

package pattern.builder.demo1;

/**
 * 指挥者类，对对象构建进行组装
 * 
 * @author ***
 * @create 2022-05-18 20:42
 */
public class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public Bike construct(){
        builder.builderFrame();
        builder.builderSeat();
        return builder.createBike();
    }
}

最后，编写测试类测试：

package pattern.builder.demo1;

/**
 * @author ***
 * @create 2022-05-18 20:46
 */
public class Client {
    public static void main(String[] args) {
        Director director = new Director(new Hello());
        Bike bike = director.construct();
        System.out.println(bike.getFrame());
        System.out.println(bike.getSeat());
    }
}

对于客户端来说，它并不需要去关注底层实现，即复杂对象（Bike对象）的构建过程以及构建算法，它直接调用指挥者类中的功能就可以构建出一个复杂对象了，继而客户端就能使用该复杂对象。