设计模式之建造者模式

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

（注意建造者模式和工厂方法有些类似，但是建造者的注重点是顺序）

优点：

1、封装性，使得客户端不必知道产品内部组成的细节。

2、建造者独立，容易扩展。

3、便于控制细节风险。

类图如下：

实现代码：

车模型抽象类：

package com.designpatterns.builder;

import java.util.ArrayList;

public abstract class CarModle {
	private ArrayList<String> al = new ArrayList<>();

	protected abstract void start();

	protected abstract void stop();

	protected abstract void alarm();

	protected abstract void engineBoom();

	protected void run() {
		for (int i = 0; al != null && i < al.size(); i++) {
			if(al.get(i).equals("start")){
				this.start();
			}else if (al.get(i).equals("stop")) {
				this.stop();
			}else if (al.get(i).equals("alarm")) {
				this.alarm();
			}else if (al.get(i).equals("engineBoom")) {
				this.engineBoom();
			}else {
				System.out.println("The car not have this function!");
			}
		}
	}

	public void setAl(ArrayList<String> al) {
		this.al = al;
	}
}

悍马车模型实现类：

package com.designpatterns.builder;

public class HummerModle extends CarModle {

	@Override
	protected void start() {
		System.out.println("hummer start!");
	}

	@Override
	protected void stop() {
		System.out.println("hummer stop!");
	}

	@Override
	protected void alarm() {
		System.out.println("hummer alarm!");
	}

	@Override
	protected void engineBoom() {
		System.out.println("hummer engineBoom!");
	}

}

奔驰车模型实现类：

package com.designpatterns.builder;

public class BenzModle extends CarModle {

	@Override
	protected void start() {
		System.out.println("Benz start!");
	}

	@Override
	protected void stop() {
		System.out.println("Benz stop!");
	}

	@Override
	protected void alarm() {
		System.out.println("Benz alarm!");
	}

	@Override
	protected void engineBoom() {
		System.out.println("Benz engineBoom!");
	}

}

建造者抽象类：

package com.designpatterns.builder;

import java.util.ArrayList;

public abstract class CarBuilder {
	public abstract void setSequence(ArrayList<String> al);
	public abstract CarModle getCarModle();
}

悍马建造者实现类：

package com.designpatterns.builder;

import java.util.ArrayList;

public class HummerBuilder extends CarBuilder {

	private HummerModle hummerModle = new HummerModle();
	@Override
	public void setSequence(ArrayList<String> al) {
		this.hummerModle.setAl(al);
	}

	@Override
	public CarModle getCarModle() {
		return this.hummerModle;
	}

}

奔驰建造者实现类：

package com.designpatterns.builder;

import java.util.ArrayList;

public class BenzBuilder extends CarBuilder {

	private BenzModle benzModle = new BenzModle();
	@Override
	public void setSequence(ArrayList<String> al) {
		this.benzModle.setAl(al);
	}

	@Override
	public CarModle getCarModle() {
		return this.benzModle;
	}

}

导演类：

package com.designpatterns.builder;

import java.util.ArrayList;

public class Director {
	private BenzBuilder benzBuilder = new BenzBuilder();
	private HummerBuilder hummerBuilder = new HummerBuilder();
	private ArrayList<String> sequence = new ArrayList<>();

	public BenzModle getbBenzModle() {
		this.sequence.clear();
		this.sequence.add("start");
		this.sequence.add("stop");

		this.benzBuilder.setSequence(sequence);
		return (BenzModle) this.benzBuilder.getCarModle();
	}

	public HummerModle gethHummerModle() {
		this.sequence.clear();
		this.sequence.add("engineBoom");
		this.sequence.add("start");
		this.sequence.add("stop");

		this.hummerBuilder.setSequence(sequence);
		return (HummerModle) this.hummerBuilder.getCarModle();
	}
}

测试类：

package com.designpatterns.builder;


public class Main {

	public static void main(String[] args) {
		Director director = new Director();
		System.out.println("------------------------------------------");
		director.getbBenzModle().run();
		System.out.println("------------------------------------------");
		director.gethHummerModle().run();
	}
}

这就是建造者模式。