软件设计 建造者模式 Builder Pattern
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
建造者模式使用多个简单的对象一步一步构建成一个复杂的对象。
一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。
经常使用的 StringBuiler 就是建造者模式的典型实现。
先来看下建造者模式的普通实现。这里模拟快餐店点餐场景：
1、定义快餐食品
/**
* 快餐食品（产品）
*/
public class Product {
/**
* 快餐 A 默认为汉堡
*/
private String BuildA = "汉堡";
/**
* 快餐 B 默认为可乐
*/
private String BuildB = "可乐";
/**
* 快餐 C 默认为薯条
*/
private String BuildC = "薯条";
/**
* 快餐 D 默认为甜点
*/
private String BuildD = "甜点";
public String getBuildA() {
return BuildA;
}
public void setBuildA(String buildA) {
BuildA = buildA;
}
public String getBuildB() {
return BuildB;
}
public void setBuildB(String buildB) {
BuildB = buildB;
}
public String getBuildC() {
return BuildC;
}
public void setBuildC(String buildC) {
BuildC = buildC;
}
public String getBuildD() {
return BuildD;
}
public void setBuildD(String buildD) {
BuildD = buildD;
}
@Override
public String toString() {
return "Product{" +
"BuildA='" + BuildA + '\'' +
", BuildB='" + BuildB + '\'' +
", BuildC='" + BuildC + '\'' +
", BuildD='" + BuildD + '\'' +
'}';
}
}
2、定义厨房
/**
* 厨房（建造者）
*/
public abstract class Kitchen {
/**
* 制作快餐 A
* @param msg 快餐名称
* @return 快餐
*/
abstract Kitchen builderA(String msg);
/**
* 制作快餐 B
* @param msg 快餐名称
* @return 快餐
*/
abstract Kitchen builderB(String msg);
/**
* 制作快餐 C
* @param msg 快餐名称
* @return 快餐
*/
abstract Kitchen builderC(String msg);
/**
* 制作快餐 D
* @param msg 快餐名称
* @return 快餐
*/
abstract Kitchen builderD(String msg);
/**
* 获取产品
* @return 产品
*/
abstract Product getProduct();
}
3、定义服务员
/**
* 服务员（传递者）
*/
public class Waiter extends Kitchen {
private Product product;
public Waiter(){
product = new Product();
}
@Override
Kitchen builderA(String msg) {
product.setBuildA(msg);
return this;
}
@Override
Kitchen builderB(String msg) {
product.setBuildB(msg);
return this;
}
@Override
Kitchen builderC(String msg) {
product.setBuildC(msg);
return this;
}
@Override
Kitchen builderD(String msg) {
product.setBuildD(msg);
return this;
}
@Override
Product getProduct() {
return product;
}
}
4、客人点餐
// 叫服务员
Waiter waiter = new Waiter();
// 可以选择套餐，省事，直接告诉服务员要套餐即可
Product product1 = waiter.getProduct();
System.out.println(product1);
// 也可以自己点餐，点了哪些上哪些
Product product2 = waiter
.builderA("炸鸡")
.builderB("雪碧")
.builderC(null)
.builderD(null)
.getProduct();
System.out.println(product2);
输出结果为：
Product{BuildA='汉堡', BuildB='可乐', BuildC='薯条', BuildD='甜点'}
Product{BuildA='炸鸡', BuildB='雪碧', BuildC='null', BuildD='null'}
优缺点：
优点
1、建造者独立，易扩展。
2、便于控制细节风险。
缺点
1、产品必须有共同点，范围有限制。
2、如内部变化复杂，会有很多的建造类。
使用场景：
1、需要生成的对象具有复杂的内部结构。
2、需要生成的对象内部属性本身相互依赖。
注意：
与工厂方法模式的区别是：建造者模式更加关注与零件装配的顺序。
