建造者模式的理解是这样的:
一件事情可以分为有限的几个步骤,或者几个部分。规定了各个步骤或部分的建造方法。然后得到一个具体的事物或者完成该事件。
其结构是这样的:
一个抽象的建造者接口
几个具体的建造者实现类
一个指挥者
一个调用者
具体先看看代码:
抽象建造者接口
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<T extends Builder> {
private T t;
public Director(Class<? extends Builder> 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<BuilderA> dA = new Director<BuilderA>(BuilderA.class);
dA.build();
Director<BuilderB> dB = new Director<BuilderB>(BuilderB.class);
dB.build();
}
}
当然,你也可以用抽象类来设计。