建造者模式

建造者模式

Builder Mode

参考了Alexander Shvets的深入设计模式

个人理解：

建造者模式，与同为创建型模式的工厂模式相比，

更注重于对象创建的过程

1.为什么有建造者模式

尝试去阐述：

假如要建一所房子，（是一个复杂对象哦）

提供一个基础的抽象类，

则可以根据房子用到的材质，占地大小，门窗个数，建造风格。。。。。。（一万个因素）

创建一万个实现类or子类

或者在一个实现类中囊括上述的所有属性，然后设计一个超级构造方法

public House(Material m,Style s,Door d,Area a.......){
    this.m = m;
    this.d = d;
    this.a = a;
    ...........
}
//-------------实际使用中可能是
public static void main(String[] args){
    House house = new House("泥巴",null,1,3,null...................);
    House house = new House("混凝土",null,1,3,null...................);
}

这样，如上有很多的参数是用不上的，也不够简洁

如此，对于复杂对象的创建的需求就催生了建造者模式

2.建造者模式的思想

建造者模式的思想是

一.将对象的创建抽取为（创建的）各个步骤（方法）

将其定义在一个接口里管理

并将该接口命名为

XXXBuilder

二.将产品也抽象为一个接口

具体的产品为其实现类。

三.创建Builder的具体实现类

并在其中组合一种具体的产品对象

在覆写的步骤方法中对具体产品的属性进行注入或修改

并提供一个获取具体产品的接口

四.通过Director类操作建造的具体的步骤

在director类中提供一种或几种流行的建造步骤（策略）

通常将Bulider的实现类组合进director类

(通过构造函数或setter注入都行)

然后在direct类中的方法中调用builder根据想要的顺序调用

建造步骤（可以调整步骤的先后，也可以选择用或不用某个步骤）

从参考的书里拿来的类图

3.代码实现

Builder接口

/**
 * 
 * @author ASUS
 * 抽象建造器接口，
 * 用于定义创建实例的各种步骤
 * 以汽车为例
 */
public interface CarBuilder {
	
	void buildEngine();
	
	void buildWheels();
	
	void buildShape();
	
	void buildTwoSets();
	
	void buildFourSets();
	
}

builder实现类

public class SportCarBuilder implements CarBuilder{
	//在其中组合一个对应的具体参评对象
	private SportCar sportcar = new SportCar();

	@Override
	public void buildEngine() {
		System.out.println("build sport car Engine------------");
		//sportcar.setXXXX(....)可以在步骤里添加产品的属性
	}

	@Override
	public void buildWheels() {
		System.out.println("build sport car Wheels------------");
		//sportcar.setXXXX(....)可以在步骤里添加产品的属性
	}

	@Override
	public void buildShape() {
		System.out.println("build sport car buildShape------------");
		//sportcar.setXXXX(....)可以在步骤里添加产品的属性
	}

	@Override
	public void buildTwoSets() {
		System.out.println("build sport car TwoSets------------");
		//sportcar.setXXXX(....)可以在步骤里添加产品的属性
	}

	@Override
	public void buildFourSets() {
		System.out.println("build sport car FourSets------------");	
		//sportcar.setXXXX(....)可以在步骤里添加产品的属性
	}

	public Car getProduct() {
		return this.sportcar;
	}
}

public class TrustCarBuilder implements CarBuilder{
     //在其中组合一个对应的具体参评对象
	private TrustCar trustcar = new TrustCar();
	
	@Override
	public void buildEngine() {
		System.out.println("build Trust car Engine------------");
		//trustcar.setXXXX(....)可以在步骤里添加产品的属性
	}

	@Override
	public void buildWheels() {
		System.out.println("build Trust car Engine------------");
		//trustcar.setXXXX(....)可以在步骤里添加产品的属性
	}

	@Override
	public void buildShape() {
		System.out.println("build Trust car Engine------------");
		//trustcar.setXXXX(....)可以在步骤里添加产品的属性
	}

	@Override
	public void buildTwoSets() {
		System.out.println("build Trust car Engine------------");
		//trustcar.setXXXX(....)可以在步骤里添加产品的属性
	}

	@Override
	public void buildFourSets() {
		System.out.println("build Trust car Engine------------");
		//trustcar.setXXXX(....)可以在步骤里添加产品的属性
	}
	
	public Car getProduct() {
		return this.trustcar;
	}

}

产品接口：

public interface Car {
	
	void Run();

}

实现产品类：

public class SportCar implements Car{

	@Override
	public void Run() {
		System.out.println("sport car running");
	}
	
}

public class TrustCar implements Car{

	@Override
	public void Run() {
		System.out.println("TrustCar Running-----------");
	}

}

Direct类：

public class Director {
	
    //组合一个具体建造器Builder
	private CarBuilder carBuilder;

	public Director(CarBuilder carBuilder) {
		this.carBuilder = carBuilder;
	}
	//通过操作构造器的实例的步骤来进行复杂对象的构造
	public void DirectLuxurySportCar() {
		carBuilder.buildEngine();
		carBuilder.buildTwoSets();
		carBuilder.buildShape();
		carBuilder.buildWheels();
	}
	
	public void DirectTrustCar() {
		carBuilder.buildEngine();
		carBuilder.buildTwoSets();
		carBuilder.buildShape();
		carBuilder.buildWheels();
	}
	
	public static void main(String[] args) {
		CarBuilder builder = new SportCarBuilder();
		Director direct = new Director(builder);
		direct.DirectLuxurySportCar();
		SportCar sportcar = (SportCar) ((SportCarBuilder)builder).getProduct();
		sportcar.Run();
	}

}

结果：

build sport car Engine------------
build sport car TwoSets------------
build sport car buildShape------------
build sport car Wheels------------
sport car running

4.想法和补充

Director类并不是必须的，

如果不通过Director类定义一些约定方案，

也可以将对象的建造步骤的操作直接交给客户端，

设计模式就是把代码的逻辑变的更抽象，

然而这也是把双刃剑

5.建造者模式的优缺点

• 你可以分步创建对象， 暂缓创建步骤或递归运行创建步骤。

• 生成不同形式的产品时， 你可以复用相同的制造代码。

• 单一职责原则。 你可以将复杂构造代码从产品的业务逻辑中分离出来。

• 由于该模式需要新增多个类， 因此代码整体复杂程度会有所增加。

!