建造者模式【创建型】

建造者模式（Builder Pattern）是一种创建型设计模式，通过将对象构造和表示分离，可以使同样的构建过程可以创建不同的表现形式。

在建造者模式中，定义一个Director（指挥者）对象，其职责是按照一定的顺序调用Builder对象来构建最终的对象。而Builder（建造者）对象则负责实际构建对象的各个部分，对外隐藏了具体的实现细节。 同时， Builder 将返回构建的对象给 Director 使用。

建造者模式的组成部分：

1. 抽象建造者（Builder）：接口或者抽象类，目的是实现复杂对象有哪些部分需要进行建造，不提供建造细节

2. 具体建造者：抽象建造者的实现类，将抽象建造者里面的方法具体化

3. 产品：需要生产的东西

4. 指挥者（Director）：调用具体建造者完成各个部分

实现案例代码实例：

使用建造者模式，实现自行车的构建，制造 ofo 和 Mopai 两种自行车，主要构建 车轮和车座

1、创建产品类，需要生产自行车【Bike】

/**
 * 产品
 **/
public class Bike {
​
    private String name;
    /**
     * 车轮
     **/
    private String carriageWheel;
​
    /**
     * 车座
     **/
    private String saddle;
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public String getCarriageWheel() {
        return carriageWheel;
    }
​
    public void setCarriageWheel(String carriageWheel) {
        this.carriageWheel = carriageWheel;
    }
​
    public String getSaddle() {
        return saddle;
    }
​
    public void setSaddle(String saddle) {
        this.saddle = saddle;
    }
​
    public Bike() {
    }
​
    public Bike(String name, String carriageWheel, String saddle) {
        this.name = name;
        this.carriageWheel = carriageWheel;
        this.saddle = saddle;
    }
}

2、创建抽象建造者，提供抽象方法

/**
 * 抽象建造者，提供抽象方法
 **/
public abstract class Builder {
​
    /**
     * 造车轮
     **/
    public abstract void buildCarriageWheel();
​
    /**
     * 造车架
     **/
    public abstract void buildSaddle();
​
    /**
     * 生产自行车
     **/
    public abstract Bike createBike();
    
}

3、创建具体的建造者

public class OfoBuilder extends Builder {
    @Override
    public void buildCarriageWheel() {
        System.out.println("造 ofo 的车轮");
    }
​
    @Override
    public void buildSaddle() {
        System.out.println("造 ofo 的车座");
    }
​
    @Override
    public Bike createBike() {
        return new Bike("ofo","ofo车轮","ofo车架");
    }
}
​
public class MopaiBuilder extends Builder {
    @Override
    public void buildCarriageWheel() {
        System.out.println("造 Mopai 的车轮");
    }
​
    @Override
    public void buildSaddle() {
        System.out.println("造 Mopai 的车座");
    }
​
    @Override
    public Bike createBike() {
        return new Bike("Mopai","摩派车轮","摩派车架");
    }
}

4、创建指挥者

/**
 * 指挥者
 **/
public class Director {
​
    /**
     * 建造者，建造自行车必须使用建造者才能完成
     **/
    private Builder builder;
​
    public Director(Builder builder) {
        this.builder = builder;
    }
​
    /**
     * 生产方法
     **/
    public Bike construct(){
        builder.buildSaddle();
        builder.buildCarriageWheel();
        Bike bike = builder.createBike();
        System.out.println(bike.getName() + " 自行车生产成功");
        return bike;
    }
}

5、测试

public static void main(String[] args) {
    //创建一个生产摩派的指挥者
    Director director = new Director(new MopaiBuilder());
    //指挥者生产自行车
    Bike bike = director.construct();
​
}
​
//测试结果
造 Mopai 的车座
造 Mopai 的车轮
Mopai 自行车生产成功

建造者模式定义了一个创建对象的标准接口，可以为不同的具体构建对象实现提供灵活性和扩展性。

当需要生产不同种类、不同风格的对象时，可以方便地创建多个Builder，并由Director来控制Build出符合需求的对象，同时又隐藏了复杂的实现细节，使得代码更加易读易维护。