前面在《重温设计模式之建造者模式（Builder）》中关于建造者模式的的介绍比较简单，代码只是实现了基本的模式，因为实际应用中不可能只考虑一个模式的，因此这里给出多个产品情况下的实现。
在那篇文章中我也提到，基本代码中的客户端需要知道的东西太多了，因此这次实现的时候我使用反射来实现。
先给出类结构图：
代码如下：
代码语言：javascript复制package builderpattern;
/**
* 抽象的建造者类
* @author the5fire
*
*/
public abstract class AbstractBuilder {
public abstract void buidPart1();
public abstract void buildPart2();
public abstract Product getProduct();
}
package builderpattern;
/**
* 具体的产品1的建造者
* @author the5fire
*
*/
public class Product1Builder extends AbstractBuilder {
private Product1 product = new Product1();
@Override
public void buidPart1() {
product.add("Builder1_add_part1");
}
@Override
public void buildPart2() {
product.add("Builder1_add_part2");
}
@Override
public Product getProduct() {
return product;
}
}
package builderpattern;
/**
* 具体的产品2的建造者
* @author the5fire
*
*/
public class Product2Builder extends AbstractBuilder {
private Product2 product = new Product2();
@Override
public void buidPart1() {
product.add("Builder2_add_part1");
}
@Override
public void buildPart2() {
product.add("Builder2_add_part2");
}
@Override
public Product getProduct() {
return product;
}
}
package builderpattern;
/**
* 具体产品1
* @author the5fire
*
*/
public class Product1 extends Product{
private static StringBuffer strPart = new StringBuffer("product1:");
public String say() {
return strPart.toString();
}
@Override
public void add(String str) {
strPart.append(str);
}
}
package builderpattern;
/**
* 具体产品2
* @author the5fire
*
*/
public class Product2 extends Product {
private static StringBuffer strPart = new StringBuffer("product2:");
public String say() {
return strPart.toString();
}
@Override
public void add(String str) {
strPart.append(str);
}
}
package builderpattern;
/**
* 指挥者类，指挥完成产品构建，供客户端调用
* @author the5fie
*
*/
public class Director {
private AbstractBuilder builder = null;
private Product product = null;
public Director(){}
/**
* 通过构造函数确定要建造那个产品
* @param productName
*/
public Director(String productName) {
try {
builder = (AbstractBuilder)Class.forName("builderpattern." productName "Builder").newInstance();
product = (Product) Class.forName("builderpattern." productName).newInstance();
System.out.println(builder.getClass().toString());
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
* 实现构建
*/
public void contruct() {
builder.buidPart1();
builder.buildPart2();
}
public Product getProduct() {
return product;
}
}
package builderpattern;
public class Client {
public static void main(String[] args) {
Director director = new Director("Product1");
director.contruct();
System.out.println(director.getProduct().say());
director = new Director("Product2");
director.contruct();
System.out.println(director.getProduct().say());
}
}不知道你发现没有，其实这些模式大多是往类上面或者两个类之间再加上一个类，也就是加上一层，来增加灵活性。那么在这个模式中我能不能够将Director也变为抽象的呢？即在其上加一个类以增加其灵活性。
