建造者模式-builder

建造者模式

1. 将一个复杂的对象的构建和表示进行分离，使得相同的构建过程创建不同的表示
2. 主要作用：在用户不知道对象建造过程和细节的情况下就可以直接创建复杂的对象
3. 用户只需要指定复杂对象的类型和内容，建造者模式负责按照顺序创建复杂对象（把内部建造过程和细节隐藏起来）

基本简图

基本实现

具体的产品Product

package com.tiko.builder.demo1;

//具体的房子，给出一些静态的属性
public class Product {

	private String buildA;
	private String buildB;
	private String buildC;

	public Product() {
	}

	public Product(String buildA, String buildB, String buildC) {
		this.buildA = buildA;
		this.buildB = buildB;
		this.buildC = buildC;
	}

	public String getBuildA() {
		return buildA;
	}

	public void setBuildA(String buildA) {
		this.buildA = buildA;
	}

	public String getBuildB() {
		return buildB;
	}

	public void setBuildB(String buildB) {
		this.buildB = buildB;
	}

	public String getBuildC() {
		return buildC;
	}

	public void setBuildC(String buildC) {
		this.buildC = buildC;
	}

	@Override
	public String toString() {
		return "Product{" +
				"buildA='" + buildA + '\'' +
				", buildB='" + buildB + '\'' +
				", buildC='" + buildC + '\'' +
				'}';
	}
}

抽象的建造者Bulider

package com.tiko.builder.demo1;

//抽象的建造者
public abstract class Builder {

	//抽象的操作
	abstract void buildA();
	abstract void buildB();
	abstract void buildC();

	//完工，给出产品
	abstract Product getProduct();
}

具体的建造者Worker

package com.tiko.builder.demo1;

//worker，按照图纸，建造具体的产品
//对于操作，只实现具体的操作，不指定操作的顺序，顺序的决定，是有指挥者决定的。
public class Worker extends Builder{

	private Product product;

	public Worker() {
		//这一步体现，工人创造产品，而不是通过接受product参数来生成产品
		this.product = new Product();
	}

	@Override
	void buildA() {
		product.setBuildA("A操作");
		System.out.println("操作A完成");
	}

	@Override
	void buildB() {
		product.setBuildB("B操作");
		System.out.println("操作B完成");
	}

	@Override
	void buildC() {
		product.setBuildC("C操作");
		System.out.println("操作C完成");
	}

	@Override
	Product getProduct() {
		return product;
	}
}

指挥者Director

package com.tiko.builder.demo1;

//指挥：核心、负责指挥构建一个工程，工程中的操作步骤如何构建，有它决定。
public class Director {

	//指挥工人，按照顺序建造房子
	public Product direct(Builder builder) {
		//这其中指定核心的构建顺序

		builder.buildC();
		builder.buildA();
		builder.buildB();
		return builder.getProduct();
	}
}

测试

package com.tiko.builder.demo1;

public class Test {

	public static void main(String[] args) {
		//指挥者
		Director director = new Director();

		//指挥 具体的工人 完成产品
		//若想改变操作顺序，修改Director即可
		//若想盖面具体的操作细节，修改Worker或创建新的Worker即可
		Product product = director.direct(new Worker());

		System.out.println(product);
	}
}

升级版实现

• 指挥者由用户自己决定，操作顺序的确定有用户自己指定。

具体的Product

package com.tiko.builder.demo2;

//具体的产品，假定一些静态的属性
//套餐
public class Product {
	//假定这些静态属性，有一些默认值
	private String builderA = "薯条";
	private String builderB = "面包";
	private String builderC = "可乐";

	public String getBuilderA() {
		return builderA;
	}

	public void setBuilderA(String builderA) {
		this.builderA = builderA;
	}

	public String getBuilderB() {
		return builderB;
	}

	public void setBuilderB(String builderB) {
		this.builderB = builderB;
	}

	public String getBuilderC() {
		return builderC;
	}

	public void setBuilderC(String builderC) {
		this.builderC = builderC;
	}

	@Override
	public String toString() {
		return "Product{" +
				"builderA='" + builderA + '\'' +
				", builderB='" + builderB + '\'' +
				", builderC='" + builderC + '\'' +
				'}';
	}
}

抽象的建造者Builder

package com.tiko.builder.demo2;

//抽象的建造者
public abstract class Builder {

	//注意此时，操作的返回值类型，为Builder类型。目的是为了实现链式编程
	abstract Builder buildA(String msg);
	abstract Builder buildB(String msg);
	abstract Builder buildC(String msg);

	//返回产品
	abstract Product getProduct();

}

具体的建造者Worker

package com.tiko.builder.demo2;

//具体的建造者，worker
public class Worker extends Builder {

	private Product product;

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

	@Override
	Builder buildA(String msg) {
		product.setBuilderA(msg);
		//this指向对象对象，谁调用，指向谁。这里结合抽象类，正好实现链式编程
		return this;
	}

	@Override
	Builder buildB(String msg) {
		product.setBuilderB(msg);
		//this指向对象对象，谁调用，指向谁。这里结合抽象类，正好实现链式编程
		return this;
}

	@Override
	Builder buildC(String msg) {
		product.setBuilderC(msg);
		//this指向对象对象，谁调用，指向谁。这里结合抽象类，正好实现链式编程
		return this;
	}

	@Override
	Product getProduct() {
		return product;
	}
}

测试

package com.tiko.builder.demo2;

public class Test {

	public static void main(String[] args) {

		//服务员1
		Worker worker = new Worker();
		Product product = worker.getProduct();
		System.out.println(product);

		//服务员2
		Worker worker2 = new Worker();
		//链式编程，在原来的基础上，可以自由组合，如果不组合，则使用默认的
		Product product2 = worker.buildA("披萨").buildB("全家桶").getProduct();
		System.out.println(product2);

	}
}

建造者与抽象工厂的比较

• 如果将抽象工厂模式看成是汽车配件的生产工厂，生产产品族的产品。那么建造者模式就是一个具体的产品（如汽车），通过对部件的组装可以返回一辆完整的汽车。一个针对产品族，一个针对具体的产品。

参考自狂神说Java