设计模式---建造者模式

package com.java.builder;

/**
 * 建造者模式 1. 开发中应用场景 
 * 					--- StringBuilder类的append方法 
 * 					----SQL中 的PreparedStatement
 *					  ----JDOM中 , DomBuilder SAXBuilder 
 * 2.本质： 分离了对象子组件的单独构造与装配 ，从而可以构造复杂的对象 
 * 适用于：
 * 某个对象构建过程复杂的情况下使用 实现了 构建和装配的解耦， 
 * 不同的构造器 相同的装配 也可以做出不同的对象 
 * 相同的装配，不同的构造器也能建造出不同的对象
 * 例如： 我们在建造一个复杂的产品航天飞船(有很多子组件)时， 
 * 问题是 装配这些子组件有很多步骤？开发过程也是一样
 */

public class AirShip {
	private OrbitalModule orbitalModule;// 轨道舱
	private Engine engine; // 发动机
	private EscapeTower escapeTower; // 逃逸塔

	
	public void launch(){
		System.out.println("发射！");
	}
	
	/**
	 * getter and setter
	 * 
	 */
	public OrbitalModule getOrbitalModule() {
		return orbitalModule;
	}

	public void setOrbitalModule(OrbitalModule orbitalModule) {
		this.orbitalModule = orbitalModule;
	}

	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 OrbitalModule {
	private String name;

	public OrbitalModule(String name) {
		super();
		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) {
		super();
		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) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}

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

}

package com.java.builder;

/**
 * 我们要建造一个飞船
 * 提供这飞船 建造的顶级接口
 * 接口中定义 各个部件的方法
 *
 */


public interface AirShipBuilder {
	Engine builderEngine();
	OrbitalModule builderOrbitalModule();
	EscapeTower builderEscapeTower();
}

package com.java.builder;

public class AirShipBuilderImpl implements AirShipBuilder{

	/**
	 * 每一个子组件都有一个有参String name的构造
	 */
	public Engine builderEngine() {
		System.out.println("构建发动机。。。。");
		return new Engine("发动机----");
	}

	
	public OrbitalModule builderOrbitalModule() {
		System.out.println("构建轨道舱。。。。。");
		return new OrbitalModule("轨道舱----");
	}

	
	public EscapeTower builderEscapeTower() {
		System.out.println("构建逃逸塔。。。。");
		return new EscapeTower("轨道舱----");
	}

}

package com.java.builder;

public interface AirShipdDirector {
	/**
	 *  组装飞船
	 */
	AirShip directAirShip();
}

package com.java.builder;

public class AirShipDirectorImpl implements AirShipdDirector{

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


	/**
	 * 完成组装 ，通过builder来实现
	 */
	public AirShip directAirShip() {
		Engine e= builder.builderEngine();
		OrbitalModule o=builder.builderOrbitalModule();
		EscapeTower et=builder.builderEscapeTower();
		
		/**
		 * 装配成飞船对象
		 */
		AirShip ship= new AirShip();
		ship.setEngine(e);
		ship.setEscapeTower(et);
		ship.setOrbitalModule(o);
		return ship;
	}

}

飞船通过装配derictor来进行--（装配时将子组件set进来）返回最终的AirShip

package com.java.builder;

public class Main {
	public static void main(String[] args) {
		AirShipdDirector director = new AirShipDirectorImpl(new AirShipBuilderImpl());

		AirShip ship = director.directAirShip();
		System.out.println(ship.getEngine().getName());
		ship.launch();
	}
}

一个类如果包含有很多的类对象，而A类里面有很多的属性 , 导致该类比较复杂,

如果我们只是简单的 T t= new T( ) 则 t 里面都是空的，比较简单的类一般是 setName(xx)注入

class T{
	A a;  
	B b;
	C c;
	D d;
}

优点：

易于解耦
将产品本身与产品创建过程进行解耦，可以使用相同的创建过程来得到不同的产品。也就说细节依赖抽象。
易于精确控制对象的创建
将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰
易于拓展
增加新的具体建造者无需修改原有类库的代码，易于拓展，符合“开闭原则“

缺点：

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

设计模式---建造者模式

猜你喜欢