建造者模式

定义:

建造者模式是指将一个复杂对象的构建与表示分离,使得创建过程可以创建不同的表示

“复杂对象的构建过程可以创建不同的表示”,可以理解成:一部汽车不论使用任何品种的品牌部件只要能正常的安装即可

“使得同样的构建过程可以创建不同的表示” 可以理解成同样的部件可以采取多种安装方式

如下图所示

1.builder 是抽象的建造者角色

          为创建一个Product产品对象的各个部件指定抽象接口

2.ConcreteBuilder 具体的建造者角色

        实现Builder的接口以构造和装配该产品的各个部件

        定义并明确它所创建的表示

3.Directer导演的角色

      构造一个使用Builder接口的对象

4.Product

      表示被构造的复杂对象ConcreteBuilder创建该产品的内部表示并定义它的装配过程.包含定义组成部件的类,包括这些部件装配成最终产品的接口

例子1.如下图

 

1.抽象的建造者:制造出一台电冰箱需要哪些部件

2.具体建造者:造出各个零件,返还电冰箱

3.导演者:厂长调用具体的建造者制造零件,生产电冰箱

4、产品角色:电冰箱

代码示例。

代码如下:

package model.builder;
/*
 * 导演者 
 * 这里由导演者指导建造者以一定的方式生产冰箱
 */
public class SiemensDirector {
	WasherBuilder builder;
	
	/*
	 * 为导演者配置一个建造者
	 */
	public SiemensDirector(WasherBuilder builder){
		this.builder = builder;
	}
	
	/*
	 * 按照一定的方式或者规则建造冰箱
	 */
	public void contruct(){
		builder.buileDeWasherSkeleton();//第一步装上冰箱框架
		builder.buildeWasherEngine();//第二步装上新型有压缩机
		builder.buildeWasherWheels();//第三步给冰箱装上轮子
		builder.BuilderWasherBody();//最后给冰箱装上门,涂上颜色
	}
}

package model.builder;

/*
 *
 */
public class SiemensWasher {
	private String washerSkeleton;
	private Compressor washerEngine;
	private String washerWheels;
	private String washerDoor;
	private String washerColor;
	
	/*
	 * 冰箱的框架
	 */
	public String getWasherSkeleton() {
		return washerSkeleton;
	}
	

	public void setWasherSkeleton(String washerSkeleton) {
		this.washerSkeleton = washerSkeleton;
	}
	
	/*
	 * 冰箱的压缩机
	 */
	public Compressor getWasherEngine() {
		return washerEngine;
	}
	
	public void setWasherEngine(Compressor washerEngine) {
		this.washerEngine = washerEngine;
	}
	
	/*
	 * 冰箱轮子
	 */
	public String getWasherWheels() {
		return washerWheels;
	}
	
	public void setWasherWheels(String washerWheels) {
		this.washerWheels = washerWheels;
	}
	
	/*
	 * 冰箱门
	 */
	public String getWasherDoor() {
		return washerDoor;
	}
	
	public void setWasherDoor(String washerDoor) {
		this.washerDoor = washerDoor;
	}
	
	/*
	 * 冰箱颜色
	 */
	public String getWasherColor() {
		return washerColor;
	}
	
	public void setWasherColor(String washerColor) {
		this.washerColor = washerColor;
	}
	
	
	/*
	 * (non-Javadoc)
	 * @see java.lang.Object#toString()
	 * 一个冰箱对象的描述
	 */
	@Override
	public String toString() {
		return "SiemensWasher [washerColor=" + washerColor + ", washerDoor="
				+ washerDoor + ", washerEngine=" + washerEngine
				+ ", washerSkeleton=" + washerSkeleton + ", washerWheels="
				+ washerWheels + "]";
	}
	
	
}

package model.builder;

/*
 * 建造冰箱的框架
 */
public interface WasherBuilder {
	/*
	 * 建造冰箱框架 抽象建造者
	 */
	public void buileDeWasherSkeleton();
	
	/*
	 *给冰箱装上压缩 
	 */
	public void buildeWasherEngine();
	
	/*
	 *给冰箱装上轮子 
	 */
	public void buildeWasherWheels();
	
	/*
	 * 安装冰箱身(包含冰箱门、涂颜色)
	 */
	public void BuilderWasherBody();
}

package model.builder;

/*
 * 具体建造者:(只是改变自己内部实现---把旧压缩机换成新压缩机)
 *
 */
public class SiemensWasherBuilder implements WasherBuilder {
	/*
	 * 具体产品对象(冰箱)
	 */
	private SiemensWasher siemensWasher = new SiemensWasher();

	/*
	 * (non-Javadoc)
	 * @see model.builder.WasherBuilder#BuilderWasherBody()
	 *安装机身(冰箱门、涂颜色)
	 */
	@Override
	public void BuilderWasherBody() {
		siemensWasher.setWasherDoor("冰箱门");
		siemensWasher.setWasherColor("银色");
	}
	/*
	 * (non-Javadoc)
	 * @see model.builder.WasherBuilder#buildeWasherEngine()
	 *给冰箱装上新的压缩机
	 */
	@Override
	public void buildeWasherEngine() {
		Compressor compressor = new Compressor("新压缩机");
		siemensWasher.setWasherEngine(compressor);
	}

	/*
	 * (non-Javadoc)
	 * @see model.builder.WasherBuilder#buildeWasherWheels()
	 * 给冰箱装上轮子
	 */
	@Override
	public void buildeWasherWheels() {
		siemensWasher.setWasherWheels("冰箱轮子");
	}
	
	/*
	 * (non-Javadoc)
	 * @see model.builder.WasherBuilder#buileDeWasherSkeleton()
	 * 给冰箱装上框架
	 */
	@Override
	public void buileDeWasherSkeleton() {
		siemensWasher.setWasherSkeleton("冰箱框架");
	}
	
	public SiemensWasher retrieveWasher(){
		return siemensWasher;
	}
}

package model.builder;

/*
 * 一个部件对象(压缩机)冰箱的核心
 *
 */
public class Compressor {
	private String name;

	public Compressor(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
}

package model.builder;
/*
 * 客户端程序
 */
public class Cilent {
	
	public static void main(String[] args) {
		//创建一个建造者对象
		SiemensWasherBuilder builder = new SiemensWasherBuilder();
		//创建一个导演,给导演分配建造者
		SiemensDirector director = new SiemensDirector(builder);
		//导演者将通知建造者去创建产品
		//在这个过程中,建造者会根据导演的请求,去创建组织并创建产品对象
		director.contruct();
		//从具体建造者中检索产品();
		SiemensWasher siemensWasher = builder.retrieveWasher();
		//显示创建好的冰箱
		System.out.println(siemensWasher.toString());
	}
}

运行结果:

建造者模式与抽象工厂区别

相同点

1.都是创建型模式

2.都将创建对象过程与使用过程相分离

3.用户需要使用对象时只需要了解创建什么,而无需了解对象如何创建

4.创建过程有所改动时，只对修改创建过程进行,而无需修改使用过程

不同点

1.构造过程的不同

建造者运用共同的构建过程形成有差异的表示

抽象工厂运用不同的构造过程形成有差异的表示

2.返回的对象不同

建造者返回整体的一个产品

抽象工厂返回相关的产品

3.客户端程序使用不同

建造者,客户端指挥抽象建造类去生成对象,并合成某些类来构成建造类

抽象工厂,客户端程序运用抽象工厂生成自需要的类