Builder(建造者模式)

Builder(建造者模式)介绍：
Builder模式是一步一步创建一个复杂对象的创建型模式，它允许用户在不知道内部构建细节的情况下，可以更
精细地控制对象的构造流程。对于比较复杂的构建情况，为了在构建过程中对外部隐藏实现细节，就可以使用
Builder模式将部件和组装过程分离，使得构建过程和部件可以自由扩展，两者之间耦合度也降到最低。

UML类图如下：

接下来带来一个实例：

一个汽车的组装有很多复杂的工序，这里就把这个过程简写成车轮，发动机，制动系统三步。

	//具体的类
public class Car {
	private String A;//车轮
	private String B;//发动机
	private String C;//制动系统
	public String getA() {
		return A;
	}
	public void setA(String a) {
		A = a;
	}
	public String getB() {
		return B;
	}
	public void setB(String b) {
		B = b;
	}
	public String getC() {
		return C;
	}
	public void setC(String c) {
		C = c;
	}
	public String toString() {
		return "Car [A=" + A + ", B=" + B + ", C=" + C + "]";
	}
}

//抽象Builder类
public abstract class Builder{
	public abstract void buildA(String A);
		
	public abstract void buildB(String B);
	
	public abstract void buildC(String C);
	
	public abstract Car create();
}

//具体Builder类
public class CarBuilder extends Builder{
	
	private Car car = new Car();

	public void buildA(String A) {
		car.setA(A);
	}

	public void buildB(String B) {
		car.setB(B);
	}

	public void buildC(String C) {
		car.setC(C);
	}

	public Car create() {
		return car;
	}
}

//Director类，负责构造Car
public class Director {

	Builder mBuilder = null;

	public Director(Builder builder) {
		mBuilder = builder;
	}
	
	public void construct(String A,String B,String C){
		mBuilder.buildA(A);
		mBuilder.buildB(B);
		mBuilder.buildC(C);
		mBuilder.create();
	}	
}

//测试类
public class Test {
	public static void main(String[] args) {
		Builder builder = new CarBuilder();
		Director director = new Director(builder);
		director.construct("大众车轮", "大众发动机", "大众制动系统");
		System.out.println(builder.create().toString());
	}
}

上述实例中，通过CarBuilder来构建Car对象，而Director封装了构建Car的复杂过程，对外隐藏构建细节。Builder
和Director一起将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的对象。
但是一般在开发过程中会去掉director,直接使用一个Builder来进行对象的组装，这个Builder通常为链式调用，
关键点在于每个setter方法都返回自身，也就是return this;代码如下：

new CarBuilder().setA().setB().setC();