Java设计模式泛型化之建造者模式

建造者模式的理解是这样的：

一件事情可以分为有限的几个步骤，或者几个部分。规定了各个步骤或部分的建造方法。然后得到一个具体的事物或者完成该事件。

其结构是这样的：

一个抽象的建造者接口
几个具体的建造者实现类
一个指挥者
一个调用者

具体先看看代码：

抽象建造者接口

public interface Builder {

	public void buildPartA();
	
	public void buildPartB();
	
	public void returnResult();
}

具体建造者实现类

public class BuilderA implements Builder {

	@Override
	public void buildPartA() {
		System.out.println("Builder A builds part A.");
	}

	@Override
	public void buildPartB() {
		System.out.println("Builder A builds part B.");
	}

	@Override
	public void returnResult() {
		System.out.println("Builder A returns part A and part B.");
	}

}

public class BuilderB implements Builder {

	@Override
	public void buildPartA() {
		System.out.println("Builder B builds part A.");
	}

	@Override
	public void buildPartB() {
		System.out.println("Builder B builds part B.");
	}

	@Override
	public void returnResult() {
		System.out.println("Builder B returns part A and part B.");
	}

}

指挥者

public class Director {

	private Builder prod;
	
	public Director(Builder prod) {
		this.prod = prod;
	}
	
	public void build() {
		prod.returnResult();
		prod.returnResult();
	}
}

调用者

public class BuilderCaller {

	public static void main(String[] args) {
		Builder builderA = new BuilderA();
		Director directorA = new Director(builderA);
		directorA.build();
		
		Builder builderB = new BuilderB();
		Director directorB = new Director(builderB);
		directorB.build();
	}
}

那么该如何泛型化呢？

不难看出，关键就在于Director类。以下是泛型化代码：

@SuppressWarnings("all")
public class Director {

	private T t;
	
	public Director(Class c) {
		try {
			t = (T) Class.forName(c.getName()).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public void build() {
		t.returnResult();
		t.returnResult();
	}
	
}

调用者

public class BuilderCaller {

	public static void main(String[] args) {
		Director dA = new Director(BuilderA.class);
		dA.build();
		
		Director dB = new Director(BuilderB.class);
		dB.build();
	}
}

当然，你也可以用抽象类来设计。