建造者模式

建造者模式：将一个复杂对象的创建和它的表示相互分离，使得同样的构建过程可以有不同的表示

建造者模式的优点：

具有很强的封装性，高层调用者不用关心具体对象的组装过程，实现高层调用和对象组装过程的解耦，对象的组装过程也是相互独立的，易于扩展

 

标准类图：

 使用建造者模式构建汽车：

汽车抽象接口：

 

package org.robbie.hibernate.generate.builder;

public interface Car {
	
	public void wheel();
	
	public void architect();
	
	public void getInfo();
	
}

为了使用属性方便和提供复用，构造了一个汽车抽象类 

 

 

package org.robbie.hibernate.generate.builder;

public abstract class AbstractCar implements Car {
	
	protected String wheelSituation;
	protected String architectSituation;

	public String getWheelSituation() {
		return wheelSituation;
	}

	public void setWheelSituation(String wheelSituation) {
		this.wheelSituation = wheelSituation;
	}

	public String getArchitectSituation() {
		return architectSituation;
	}

	public void setArchitectSituation(String architectSituation) {
		this.architectSituation = architectSituation;
	}
	
	@Override
	public void wheel() {
		System.out.println(this.wheelSituation);
	}

	@Override
	public void architect() {
		System.out.println(this.architectSituation);
	}
}

 

 

具体汽车类： 

 

package org.robbie.hibernate.generate.builder;

public class BMW extends AbstractCar implements Car{


	@Override
	public void getInfo() {
		System.out.println("this is bmw: wheel is " 
				+ super.wheelSituation + " and architect is " 
					+ super.architectSituation);
	}

	

}

 

package org.robbie.hibernate.generate.builder;

public class Benz extends AbstractCar implements Car {

	@Override
	public void getInfo() {
		System.out.println("this is benz: wheel is " 
								+ super.wheelSituation + " and architect is " 
										+ super.architectSituation);
	}
	

}

 建造者抽象：

 

package org.robbie.hibernate.generate.builder;

public interface Builder {
	
	Car build(BluePrint bluePrint);
	
}

 具体的建造者：

 

 

package org.robbie.hibernate.generate.builder;

public class BMWBuilder implements Builder{

	@Override
	public Car build(BluePrint bluePrint) {
		BMW bmw = new BMW();
		bmw.setWheelSituation(bluePrint.getWheel());
		bmw.setArchitectSituation(bluePrint.getArchitect());
		return bmw;
	}
	
}

 

package org.robbie.hibernate.generate.builder;

public class BenzBuilder implements Builder{

	@Override
	public Car build(BluePrint bluePrint) {
		Benz benz = new Benz();
		benz.setArchitectSituation(bluePrint.getWheel());
		benz.setWheelSituation(bluePrint.getWheel());
		return benz;
	}

}

 蓝图类（建造者根据蓝图建造汽车）：

 

 

package org.robbie.hibernate.generate.builder;

public class BluePrint {

	private String wheel;

	private String architect;

	public String getWheel() {
		return wheel;
	}

	public void setWheel(String wheel) {
		this.wheel = wheel;
	}

	public String getArchitect() {
		return architect;
	}

	public void setArchitect(String architect) {
		this.architect = architect;
	}

}

 指导者(创建具体的蓝图交给建造者进行建造，指导者也可以进行抽象)：

package org.robbie.hibernate.generate.builder;

public class Director {
	
	private Builder benzBuilder = new BenzBuilder();
	private Builder BMWBuilder = new BMWBuilder();
	
	public Car createBigWheelBmw(){
		BluePrint bluePrint = new BluePrint();
		bluePrint.setArchitect("半独立悬挂系统");
		bluePrint.setWheel("大轮胎");
		return BMWBuilder.build(bluePrint);
	}
	
	public Car createStandardArchitectBmw(){
		BluePrint bluePrint = new BluePrint();
		bluePrint.setArchitect("独立悬挂系统");
		bluePrint.setWheel("小轮胎");
		return BMWBuilder.build(bluePrint);
	}
	
	public Car createSmallWheelBenz(){
		BluePrint bluePrint = new BluePrint();
		bluePrint.setArchitect("独立悬挂系统");
		bluePrint.setWheel("小轮胎");
		return benzBuilder.build(bluePrint);
	}
	
	public Car createHalfStandardArchitectBenz(){
		BluePrint bluePrint = new BluePrint();
		bluePrint.setArchitect("半独立悬挂系统");
		bluePrint.setWheel("大轮胎");
		return benzBuilder.build(bluePrint);
	}
	
}

 

 

场景类：

package org.robbie.hibernate.generate.builder;

public class Client {
	
	public static void main(String[] args) {
		Director director = new Director();
		Car bmw1 = director.createBigWheelBmw();
		Car bmw2 = director.createStandardArchitectBmw();
		Car benz1 = director.createSmallWheelBenz();
		Car benz2 = director.createHalfStandardArchitectBenz();
		bmw1.getInfo();
		bmw2.getInfo();
		benz1.getInfo();
		benz2.getInfo();
	}
	
}