1. 前文汇总
2. 建造者模式定义
建造者模式（Builder Pattern）也叫做生成器模式，其定义如下：
Separate the construction of a complex object from its representation sothat the same construction process can create different representations.（将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。）
通用类图：
- Product: 产品类，通常是实现了模板方法模式，也就是有模板方法和基本方法。
- Builder: 抽象建造者，规范产品的组建，一般是由子类实现。
- ConcreteBuilder: 具体建造者，实现抽象类定义的所有方法，并且返回一个组建好的对象。
- Director: 导演类，负责安排已有模块的顺序，然后告诉 Builder 开始建造。
通用代码示例：
Product 产品类：
public class Product {
public void doSomething() {
// 业务处理
}
}
Builder 抽象建造者：
public abstract class Builder {
// 设置产品不同的部分，用来获得不同的产品
abstract void setPart();
// 建造产品
abstract Product buildProduct();
}
ConcreteBuilder 具体建造者：
public class ConcreteProduct extends Builder{
private Product product = new Product();
@Override
void setPart() {
// 独特的处理逻辑
}
@Override
Product buildProduct() {
return product;
}
}
Director 导演类：
public class Director {
private Builder builder = new ConcreteProduct();
public Product getProduct() {
builder.setPart();
// 设置不同的 part ，生产不同的零件
return builder.buildProduct();
}
}
3. 通过建造者模式造一辆共享单车
接下来使用建造者模式造一辆共享单车。
经历过共享单车大战之后，现在共享单车还在运营活着的也没几家了，在大街上比较常看到的有美团单车和哈罗单车，先创建一个抽象的产品类：
public abstract class AbstractBike {
// 各个零件制造顺序
private ArrayList<String> sequence = new ArrayList<> ();
// 自行车车架
protected abstract void frame();
// 自行车座位
protected abstract void seat();
// 自行车轮子
protected abstract void tire();
// 生产方法
final public void createBike() {
for (int i = 0; i < sequence.size(); i++) {
String actionName = this.sequence.get(i);
if (actionName.equalsIgnoreCase("frame")) {
this.frame();
} else if (actionName.equalsIgnoreCase("seat")) {
this.seat();
} else if (actionName.equalsIgnoreCase("tire")) {
this.tire();
}
}
}
final public void setSequence(ArrayList sequence) {
this.sequence = sequence;
}
}
在这个产品类中，定义了三个零件和一个零件的制造顺序，在单车的生产方法中，通过循环制造顺序，可以制造的顺序进行控制。
接下来是两个具体的产品类：
public class HelloBike extends AbstractBike {
@Override
protected void frame() {
System.out.println("现在开始生产一个哈罗车架");
}
@Override
protected void seat() {
System.out.println("现在开始生产一个哈罗座位");
}
@Override
protected void tire() {
System.out.println("现在开始生产两个哈罗轮胎");
}
}
public class MeituanBike extends AbstractBike {
@Override
protected void frame() {
System.out.println("现在开始生产一个美团车架");
}
@Override
protected void seat() {
System.out.println("现在开始生产一个美团座位");
}
@Override
protected void tire() {
System.out.println("现在开始生产两个美团轮胎");
}
}
接下来创建一个抽象的 Builder ：
public abstract class Builder {
// 创建一个生产顺序模型
public abstract void setSequence(ArrayList<String> sequence);
// 生产完成后获取这个车辆模型
public abstract AbstractBike getBike();
}
然后是两个具体的建造者：
public class HelloBuilder extends Builder {
private HelloBike helloBike = new HelloBike();
@Override
public void setSequence(ArrayList<String> sequence) {
this.helloBike.setSequence(sequence);
}
@Override
public AbstractBike getBike() {
return this.helloBike;
}
}
public class MeituanBuilder extends Builder {
private MeituanBike meituanBike = new MeituanBike();
@Override
public void setSequence(ArrayList<String> sequence) {
this.meituanBike.setSequence(sequence);
}
@Override
public AbstractBike getBike() {
return this.meituanBike;
}
}
最后是一个导演类：
public class Director {
private ArrayList<String> sequence = new ArrayList<>();
private HelloBuilder helloBuilder = new HelloBuilder();
private MeituanBuilder meituanBuilder = new MeituanBuilder();
public HelloBike getHelloBike() {
this.sequence.clear();
// 自定义生产的顺序
this.sequence.add("frame");
this.sequence.add("seat");
this.sequence.add("tire");
this.helloBuilder.setSequence(sequence);
return (HelloBike) this.helloBuilder.getBike();
}
public MeituanBike getMeituanBike() {
this.sequence.clear();
// 定义生产的顺序
this.sequence.add("seat");
this.sequence.add("tire");
this.sequence.add("frame");
this.meituanBuilder.setSequence(sequence);
return (MeituanBike) this.meituanBuilder.getBike();
}
}
然后写一个 Test 类进行一下测试：
public class Test {
public static void main(String[] args) {
Director director = new Director();
director.getHelloBike().createBike();
}
}
运行结果是：
现在开始生产一个哈罗车架
现在开始生产一个哈罗座位
现在开始生产两个哈罗轮胎
最后放一个这个示例的 UML 类图：