建造者模式

客机已经是很常见的交通工具了，对于每一位乘客来讲，我们不用关心飞机内部的复杂构造（发动机、轨道舱、逃离塔）。只需要根据知道客机可以用于交通运输。对于用户而言我们总是希望我们在使用对象时足够简单，如果一个复杂的对象直接丢给用户，用户会是痛苦不堪的(给你一堆部件，你来组装成一架飞机看看)，除了这个构建的过程外，可能用户会忘记某些成员属性。所以我们就希望能够像乘坐飞机一样使用复杂的对象：直接告诉你我需要的对象名或者对象类型，你返回一个完成的对象实例给我。建造者返回给客户一个完整的的产品对象，而客户端无须关心该对象所包含的额属性和组建方式，这就是建造者模式的设计动机。

模式定义

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

          如果我们用了建造者模式，那么用户就只需要指定需要建造的类型就可以得到他们，而具体的过程以及细节就不需要知道。

模式结构

模式实现

product类----产品类

package com.bjsxt.builder;

/**
 * 宇宙飞船
 * @author Administrator
 *
 */
public class AirShip {

	private ObitalModule obitalModule;//轨道舱
	private Engine engine;//发动机
	private EscapeTower escapeTower;//逃逸塔
	
	
	public void launch(){
		System.out.println("发射，点火");
	}
	
	
	public ObitalModule getObitalModule() {
		return obitalModule;
	}
	public void setOrbitalModule(ObitalModule obitalModule) {
		this.obitalModule = obitalModule;
	}
	public Engine getEngine() {
		return engine;
	}
	public void setEngine(Engine engine) {
		this.engine = engine;
	}
	public EscapeTower getEscapeTower() {
		return escapeTower;
	}
	public void setEscapeTower(EscapeTower escapeTower) {
		this.escapeTower = escapeTower;
	}
	
	
	
}

class ObitalModule{
	private String name;

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

	public String getName() {
		return name;
	}

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

class Engine{
	private String name;

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

	public String getName() {
		return name;
	}

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

class EscapeTower{
	private String name;

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

	public String getName() {
		return name;
	}

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

Builder类----建造者类

package com.bjsxt.builder;

public interface AirShipBuilder {
	Engine builderEngine();
	ObitalModule builderObitalModule();
	EscapeTower builderEscapeTower();
}

package com.nchu.builder;

public class SxtAirShipBuilder implements AirShipBuilder{

	@Override
	public Engine builderEngine() {
		System.out.println("构建nchu发动机！");
		return new Engine("nchu发动机");
	}

	@Override
	public ObitalModule builderObitalModule() {
		System.out.println("构建轨道舱");
		return new ObitalModule("构建轨道舱");
	}

	@Override
	public EscapeTower builderEscapeTower() {
		System.out.println("构建逃逸塔");
		return new EscapeTower("构建逃逸塔");
	}

}

Diretor类----指挥者类

package com.nchu.builder;

public interface AirShipDirector {
	/**
	 * 组装飞船对象
	 * @return
	 */
	AirShip directAirShip();
}
package com.nchu.builder;

public class SxtAirShipDirector implements AirShipDirector {

	private AirShipBuilder builder;
	
	
	public SxtAirShipDirector(AirShipBuilder builder) {
		this.builder = builder;
	}


	@Override
	public AirShip directAirShip() {
		
		Engine e = builder.builderEngine();
		ObitalModule o = builder.builderObitalModule();
		EscapeTower et = builder.builderEscapeTower();
		
		//配置飞行器
		AirShip ship = new AirShip();
		ship.setEngine(e);
		ship.setEscapeTower(et);
		ship.setObitalModule(o);
		
		return ship;
	}

}

client----客户端类

package com.nchu.builder;

public class Client {

	public static void main(String[] args) {
		AirShipDirector director = new SxtAirShipDirector(new SxtAirShipBuilder());
	
		AirShip ship = director.directAirShip();
		
		System.out.print(ship.getEngine().getName());
		ship.launch();
	}
}

模式优缺点

        优点   

            1、将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，使得我们能够更加精确的控制复杂对象的产生过程。

        2、将产品的创建过程与产品本身分离开来，可以使用相同的创建过程来得到不同的产品。也就说细节依赖抽象。

        3、每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。

        缺点

         1、建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。 
      2、如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

使用场景

            1、每一个对象的算法独立于该对象的组成部分以及他们的装配方式时。

           2、当构造的对象允许被构造的对象有不同的变现时。

模式总结

            1、 建造者模式是将一个复杂对象的创建过程给封装起来，客户只需要知道可以利用对象名或者类型就能够得到一个完整的对象实例，而不需要关心对象的具体创建过程。

           2、建造者模式将对象的创建过程与对象本身隔离开了，使得细节依赖于抽象，符合依赖倒置原则。可以使用相同的创建过程来创建不同的产品对象。