设计模式的学习(4)建造者模式

建造者模式

又称生成器模式，属于建立型模式。

 

主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的建立工做，该对象一般包含多个子对象（成员属性），并且子对象（成员属性）的值都是通过必定的算法才获得；因为需求的变化，这个复杂对象的各个部分常常面临着剧烈的变化，可是将它们组合在一块儿的算法却相对稳定。

什么时候使用：一些基本部件不会变，而其组合常常变化的时候。

意图：将一个复杂的构建与其表示相分离，使得一样的构建过程能够建立不一样的表示。

别慌，看到上面这句话可能很陌生，可是看完下面的例子，就会完全明白这句话的意思。

 

再来看下建造者模式的四个角色：抽象建造者builder、具体的建造者ConcereteBuilder、监工(指挥)Director、产品角色(最后被建立的实例)Product

产品角色Product：产品即是建造完毕后的复杂对象。

这个对象也包含成员变量，可是它的成员变量，多是java基本类型，也多是其余复杂对象，还多是通过业务流程后的返回结果。

抽象建造者builder：定义了生成产品（实例）所须要的全部方法；       

能够看作定义了一个接口，它定义了构建一个产品实例，须要哪些属性。而且最后还要定义一个获取（返回）产品实例的方法。

具体的建造者角色ConcereteBuilder：能够看作是接口的实现类，通过重写，实现了生成产品实例所须要的全部方法，而且定义获取（返回）最终生成实例的方法。就是说，抽象建造者builder只是定义了产品实例的组成，和获取方法，而具体的建造者角色ConcreteBuilder经过实现接口的方式重写了产品实例的组成和获取方法。说明能够有多个具体的建造者角色ConcereteBuilder实现类，各自定义本身的生成产品实例所须要的方法。

监工角色Director：担任这个角色的类是独立的，它和复杂对象的构建过程没有关系。

它的做用：

1.定义获取产品实例的方法给使用者调用，保证产品实例是从监工类里拿到的。

2.在获取产品实例的方法中，执行抽象建造者builder定义的构建方法，但经过传入外部参数，影响构建结果。由于抽象建造者builder接口能够有不少个实现类。

 

四中角色起到的做用：

产品实例的构建方法定义在抽象建造者builder接口中

产品实例的构建过程，定义在建造者角色ConcereteBuilder接口的实现类中

想要得到产品实例，须要经过监工角色Director定义的方法

而在监工类定义的方法中，统一调用抽象建造者builder接口中定义的方法，可是由于具体的建造者角色ConcereteBuilder是接口的实现类，因此在构建产品实例的过程当中，传入参数不一样，好比传入不一样的具体的建造者角色ConcereteBuilder，不一样的实现类，执行了各自的构建方法，返回的结果就不一样。

这就达到了，将一个复杂的构建与其表示相分离，使得一样的构建过程能够建立不一样的表示。这个目的了。

注意：定义中“将一个复杂的构建过程与其表示相分离”，表示并非由建造者负责一切，而是由监工负责控制（定义）一个复杂的构建过程，由各个不一样的建造者分别负责实现构建过程当中所用到的全部构建步骤。否则，就没法作到“使得一样的构建过程能够建立不一样的表示”这一目标。

1.产品角色Product

/**
 * 产品角色Product的实体类
 * 
 */
public class Human {

	private String head;
	private String body;
	private String hand;
	private String foot;

	public String getHead() {
		return head;
	}

	public void setHead(String head) {
		this.head = head;
	}

	public String getBody() {
		return body;
	}

	public void setBody(String body) {
		this.body = body;
	}

	public String getHand() {
		return hand;
	}

	public void setHand(String hand) {
		this.hand = hand;
	}

	public String getFoot() {
		return foot;
	}

	public void setFoot(String foot) {
		this.foot = foot;
	}

}

2.建立抽象建造者Builder

/**
 * 抽象建造者builder 一个接口，定义了Human属性的构建方法，和返回Human实例的方法
 */
public interface HumanBuilder {
	public void buildHead(String str);

	public void buildBody(String str);

	public void buildHand(String str);

	public void buildFoot(String str);

	public Human createHuman();
}

3.建立多个具体的建造者角色ConcereteBuilder

/**
 * 具体的建造者角色ConcreteBuilder 抽象建造者builder 接口的实现类
 * 该具体的建造者，重写了抽象建造者定义的全部方法，能够表明某类具备本身个性的人类
 * 
 * 这里表明，天赋自由的人
 */
public class FreeHumanConcereBuilder implements HumanBuilder {
	Human human;

	public FreeHumanConcereBuilder() {
		human = new Human();
	}

	public void buildHead(String str) {
		human.setHead(str);

	}

	public void buildBody(String str) {
		human.setBody(str);

	}

	public void buildHand(String str) {
		human.setHand(str);

	}

	public void buildFoot(String str) {
		human.setFoot(str);
	}

	public Human createHuman() {
		return human;
	}

}

 

/**
 * 具体的建造者角色ConcreteBuilder 抽象建造者builder 接口的实现类
 * 该具体的建造者，重写了抽象建造者定义的全部方法，能够表明某类具备本身个性的人类
 * 
 * 这里表明，聪明的人
 */
public class SmartHumanConcereBuilder implements HumanBuilder {
	Human human;

	public SmartHumanConcereBuilder() {
		human = new Human();
	}

	public void buildHead(String str) {
		human.setHead("聪明");

	}

	public void buildBody(String str) {
		human.setBody("通常");

	}

	public void buildHand(String str) {
		human.setHand("通常");

	}

	public void buildFoot(String str) {
		human.setFoot("通常");
	}

	public Human createHuman() {
		return human;
	}

}

.

/**
 * 具体的建造者角色ConcreteBuilder 抽象建造者builder 接口的实现类
 * 该具体的建造者，重写了抽象建造者定义的全部方法，能够表明某类具备本身个性的人类
 * 
 * 这里表明，强壮的人
 */
public class StrongHumanConcereBuilder implements HumanBuilder {
	Human human;

	public StrongHumanConcereBuilder() {
		human = new Human();
	}

	public void buildHead(String str) {
		human.setHead("通常");

	}

	public void buildBody(String str) {
		human.setBody("强壮");

	}

	public void buildHand(String str) {
		human.setHand("强壮");

	}

	public void buildFoot(String str) {
		human.setFoot("强壮");
	}

	public Human createHuman() {
		return human;
	}
}

4.监工角色Director

/**
 * 监工角色Director 它不参与产品实例的构建过程，构建过程是由具体构建者实现的 它给使用者提供获取产品实例的方法
 * 经过调用抽象建造者定义的方法，返回构建结果 可是它能够传入自定义参数，返回不一样的实现
 */
public class Director {
	public Human getHuman(HumanBuilder bh, String head,
			String body, String hand, String foot) {
		bh.buildBody(body);
		bh.buildFoot(foot); 
		bh.buildHand(hand);
		bh.buildHead(head);
		return bh.createHuman();
	}
}

5.建立请求者

public class Main {
	public static void main(String[] args) {
		Director director = new Director();
		Human smartHuman = director.getHuman(new SmartHumanConcereBuilder(),
				"", "", "", "");
		System.out.println("聪明的人：");
		System.out.println(smartHuman.getHead());
		System.out.println(smartHuman.getBody());
		System.out.println(smartHuman.getHand());
		System.out.println(smartHuman.getFoot());

		Human strongHuman = director.getHuman(new StrongHumanConcereBuilder(),
				"", "", "", "");
		System.out.println("强壮的人：");
		System.out.println(strongHuman.getHead());
		System.out.println(strongHuman.getBody());
		System.out.println(strongHuman.getHand());
		System.out.println(strongHuman.getFoot());

		Human freeHuman = director.getHuman(new FreeHumanConcereBuilder(),
				"聪明", "强壮", "通常", "通常");
		System.out.println("自由的人：");
		System.out.println(freeHuman.getHead());
		System.out.println(freeHuman.getBody());
		System.out.println(freeHuman.getHand());
		System.out.println(freeHuman.getFoot());

	}
}

6.输出请求结果，咱们看到：将一个复杂的构建与其表示相分离，使得一样的构建过程能够建立不一样的表示。

聪明的人：聪明 通常 通常 通常 强壮的人：通常 强壮 强壮 强壮 自由的人：聪明 强壮 通常 通常