菜鸟学设计模式系列笔记之建造者模式（Builder模式）

提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化。

从而保持系统中的“稳定构建算法”不随需求变化而变化。————建造者模式

建造模式是对象的创建模式

建造模式可以将一个产品的内部表象与产品的生成过程分割开来，

从而可以是一个建造过程生成具有不同的内部表象的产品对象。

Intent :

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

Motivation：

在复杂对象的构造过程中，允许同样的构造过程能够加入新的被构造元素，结构化构造过程

建造模式利用一个导演者对象和具体建造者对象一个一个地建造出所有的零件，从而建造出完整的对象。

建造者模式将产品的结构和产品的零件建造过程对客户端隐藏起来，把对建造过程进行指挥的责任和具体建造者零件的责任分割开来，达到责任划分和封装的目的。

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

ConcreteBulider ：

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

定义并申明他所创建的表示；

提供一个检索产品的接口

Director：

够做一个使用Builder接口的对象

Product

表示被构造的复杂对象；包含定义组成部件的类，包括这些部件装配成最终产品的接口

 在联机射击游戏中每一个游戏人物角色都需要提供一个完整
的角色造型，包括人物造型、服装、武器等，如何创建一个
完整的游戏角色？

public class Clothing {

	public Clothing() {
		super();
		// TODO Auto-generated constructor stub
		System.out.println("Clothing new");
	}
	
}

public class Character {

	public Character() {
		super();
		// TODO Auto-generated constructor stub
		System.out.println("Character new");
	}
	
}

public class Weapon {

	public Weapon() {
		super();
		// TODO Auto-generated constructor stub
		System.out.println("weapon new");
	}
	
}

public class Role {	
	private Clothing clothing;
	private Character character;
	private Weapon weapon;
	
	public Role() {
		System.out.println("Role() new");
	}
	
	public Role(Clothing clothing, Character character, Weapon weapon) {
		super();
		System.out.println("role(ccp) new");
		this.clothing = clothing;
		this.character = character;
		this.weapon = weapon;
	}

	public Clothing getClothing() {
		return clothing;
	}
	public void setClothing(Clothing clothing) {
		this.clothing = clothing;
	}
	public Character getCharacter() {
		return character;
	}
	public void setCharacter(Character character) {
		this.character = character;
	}
	public Weapon getWeapon() {
		return weapon;
	}
	public void setWeapon(Weapon weapon) {
		this.weapon = weapon;
	}
	
}

public interface RoleBuilder {
	public void buildClothing();
	public void buildCharacter();
	public void buildWeapon();
	public Role getRole();
}

public class ConcreteRoleBuilder implements RoleBuilder {
	protected Role role=new Role();
	@Override
	public void buildClothing() {
		// TODO Auto-generated method stub
		role.setClothing(new Clothing());
	}
	@Override
	public void buildCharacter() {
		// TODO Auto-generated method stub
		role.setCharacter(new Character());
	}
	@Override
	public void buildWeapon() {
		// TODO Auto-generated method stub
		role.setWeapon(new Weapon());
	}

	@Override
	public Role getRole() {
		// TODO Auto-generated method stub
		return role;
	}
	
}

public class Director {
	private RoleBuilder roleBuilder;
	
	public Director(RoleBuilder roleBuilder) {
		super();
		System.out.println("director new");
		this.roleBuilder = roleBuilder;
	}

	public void setBulider(RoleBuilder roleBuilder){
		this.roleBuilder=roleBuilder;
	}


	public Role construct() {
		roleBuilder.buildCharacter();
		roleBuilder.buildClothing();
		roleBuilder.buildWeapon();
		return roleBuilder.getRole();
	}
}

public class Client {
	public static final void main(String[] args){
		RoleBuilder builder =new ConcreteRoleBuilder();
		Director director=new Director(builder);
		Role role =director.construct();
	}
}

建造者模式特点：

1、建造者模式的“加工工艺”是暴露的。这样使得建造者模式更加灵活。

2、解耦了组装过程和创建具体部件，使得我们不用去关心每个部件是如何组装的。

实现要点：

1、建造者模式主要用于“分步骤构建一个复杂的对象”，在这其中“分步骤”是一个稳定算法，而复杂对象的各个部分则经常变化。

2、产品不需要抽象类，不大可能提炼出一个抽象的产品类。

3、创建者中的创建子部件的接口方法不是抽象方法而是空方法，不进行任何操作，

具体的创建者只需要覆盖的方法就可以，但是这也不是绝对的，特鄙视的类似文本转换这种情况下，缺省的方法将输入原封不动的输出是合理的缺省操作。

4、抽象工厂模式解决“系列对象”的需求变化，Builder模式解决“对象部分”的需求变化，

建造者模式常和组合模式结合使用。

建造者模式应用场景：

（1）需要生成一个产品对象有复杂的内部结构。每一个内部成分本身可以是对象，也可以使一个对象的一个组成部分。

（2）需要生成的产品对象的属性相互依赖。建造模式可以强制实行一种分步骤进行的建造过程。

（3）在对象创建过程中会使用到系统中的其他一些对象，这些对象在产品对象的创建过程中不易得到