建造者模式

建造者模式用于生产构建流程较为复杂的对象。
它与抽象工厂的区别在于：
建造者模式增加了一个Director类，封装了对象的构建流程，返回一个整体；
抽象工厂返回的是产品的部件。
为了更好的区分建造者和抽象工厂，在这个demo中嵌入了抽象工厂。

package builder;

public interface WheelFactory {
	void getWheel();
}

package builder;

public class BenzWheelFactory implements WheelFactory{

	@Override
	public void getWheel() {
		System.out.println("生产奔驰轮胎");
	}

}

package builder;

public class ToyotaWheelFactory implements WheelFactory{

	@Override
	public void getWheel() {
		System.out.println("生产丰田轮子");
	}
	
}

package builder;

public interface EngineFactory {
	void getEngine();
}

package builder;

public class BenzEngineFactory implements EngineFactory{

	@Override
	public void getEngine() {
		System.out.println("生产奔驰引擎");
	}
	
}

package builder;

public class ToyotaEngineFactory implements EngineFactory{

	@Override
	public void getEngine() {
		System.out.println("生产丰田引擎");
	}
	
}

package builder;

public interface CarBuilder {
	//生产轮子
	void produceWheel();
	//生产引擎
	void produceEngine();
	//刷漆
	void paint();
	//安装内饰
	void innerDecoration();
}

package builder;

public class BenzCarBuilder implements CarBuilder{
	
	private WheelFactory benzWheelFactory=new BenzWheelFactory(); 
	
	private EngineFactory benzEngineFactory=new BenzEngineFactory();
	
	@Override
	public void produceWheel() {
		benzWheelFactory.getWheel();
	}

	@Override
	public void produceEngine() {
		benzEngineFactory.getEngine();
	}

	@Override
	public void paint() {
		System.out.println("刷奔驰油漆");
	}

	@Override
	public void innerDecoration() {
		System.out.println("装奔驰内饰");
	}

	
	
}

package builder;

public class ToyotaCarBuilder implements CarBuilder{
	
	private WheelFactory toyotaWheelFactory=new ToyotaWheelFactory();
	
	private EngineFactory toyotaEngineFactory=new ToyotaEngineFactory();
	
	@Override
	public void produceWheel() {
		toyotaWheelFactory.getWheel();
	}

	@Override
	public void produceEngine() {
		toyotaEngineFactory.getEngine();
	}

	@Override
	public void paint() {
		System.out.println("刷丰田漆");
	}

	@Override
	public void innerDecoration() {
		System.out.println("装丰田内饰");
	}
	
}

package builder;

public class Director {
	
	private CarBuilder benzCarBuilder=new BenzCarBuilder();
	
	private CarBuilder toyotaCarBuilder=new ToyotaCarBuilder();
	
	public void benzConstruction() {
		benzCarBuilder.produceWheel();
		benzCarBuilder.produceEngine();
		benzCarBuilder.paint();
		benzCarBuilder.innerDecoration();
	}
	
	public void toyotaConstruction() {
		toyotaCarBuilder.innerDecoration();
		toyotaCarBuilder.paint();
		toyotaCarBuilder.produceEngine();
		toyotaCarBuilder.produceWheel();
	}
}
package builder;

public class Client {
	public static void main(String[] args) {
		Director director=new Director();
		director.benzConstruction();
		director.toyotaConstruction();
	}
}	

打印结果：
生产奔驰轮胎
生产奔驰引擎
刷奔驰油漆
装奔驰内饰
装丰田内饰
刷丰田漆
生产丰田引擎
生产丰田轮子

小结：
1.与抽象工厂区别，通过添加了Director，隐藏了构建细节，提供一个完整对象，在这个例子中，生产轮胎、生产引擎使用了抽象工厂模式，抽象工厂参见抽象工厂；