前提
听这名字，大概都能想到建造者模式的大概。小时候大家都玩过搭积木吧，那么这个所谓的建造者模式就和这个搭积木差不多。
介绍
建造者模式的官方定义为：将一个复杂对象的构建与他的表示分离，使得同样的构建过程可以创建不同的表示。
仔细揣摩这句话：首先对象应该是复杂的，不然不需要使用模式了，其次对象的结构应该是有限多样的。有限多样怎么理解呢？还是拿积木做比较，积木中各种积木都有，因而导致可以组成多种玩具，但是毕竟积木种类和数量有限，因而能组成的玩具种类也有限，而且单单改变积木的组装过程就能得到不同的玩具出来，符合定义说的构建和表示分离。
使用方式
建造者模式使用很简单，只需按照UML定义图使用，写了这么多年代码，也观察了大牛们代码，发现使用建造者模式有两种方式。
规矩模式
abstract public class Product {
private String mName;
public String getName() {
return mName;
}
public void setName(String name) {
mName = name;
}
abstract public void doSomethingA();
abstract public void doSomethingB();
abstract public void doSomethingC();
abstract public void doOtherthing();
}
public class ConcreteProduct extends Product{
public void doSomethingA()
{
System.out.println("Product doSomethingA()");
}
public void doSomethingB()
{
System.out.println("Product doSomethingB()");
}
public void doSomethingC()
{
System.out.println("Product doSomethingC()");
}
public void doOtherthing()
{
System.out.println("Product doOtherthing()");
}
}
abstract public class Builder {
protected Product mProduct;
abstract public Product build();
}
public class ConcreteBuilder extends Builder{
public ConcreteBuilder()
{
mProduct = new ConcreteProduct();
}
public ConcreteBuilder buildPartA()
{
System.out.println("Builder buildPartA()");
mProduct.doSomethingA();
return this;
}
public ConcreteBuilder buildPartB()
{
System.out.println("Builder buildPartB()");
mProduct.doSomethingB();
return this;
}
public ConcreteBuilder buildPartC()
{
System.out.println("Builder buildPartC()");
mProduct.doSomethingC();
return this;
}
@Override
public Product build() {
return mProduct;
}
}
public class Main {
public static void main(String[] args) throws Exception {
Product product = new ConcreteBuilder().buildPartA().buildPartB().buildPartC().build();
product.doOtherthing();
}
}
运行结果如下：
Builder buildPartA()
Product doSomethingA()
Builder buildPartB()
Product doSomethingB()
Builder buildPartC()
Product doSomethingC()
Product doOtherthing()
这种就是最普通的写法，虽然比定义多了一个Product抽象类，但本着依赖倒转的原则在对象复杂的时候适应性很好，缺点就是繁琐了点，下面介绍另一种写法。
偷懒模式
public class LazyProduct {
public static class LazyBuild
{
private LazyProduct mProduct = new LazyProduct();
public LazyBuild buildPartA()
{
System.out.println("Builder buildPartA()");
mProduct.doSomethingA();
return this;
}
public LazyBuild buildPartB()
{
System.out.println("Builder buildPartB()");
mProduct.doSomethingB();
return this;
}
public LazyBuild buildPartC()
{
System.out.println("Builder buildPartC()");
mProduct.doSomethingC();
return this;
}
public LazyProduct build() {
return mProduct;
}
}
private String mName;
public String getName() {
return mName;
}
public void setName(String name) {
mName = name;
}
public void doSomethingA()
{
System.out.println("Product doSomethingA()");
}
public void doSomethingB()
{
System.out.println("Product doSomethingB()");
}
public void doSomethingC()
{
System.out.println("Product doSomethingC()");
}
public void doOtherthing()
{
System.out.println("Product doOtherthing()");
}
}
public class Main {
public static void main(String[] args) throws Exception {
new LazyProduct.LazyBuild().buildPartA().buildPartB().buildPartC().build().doOtherthing();
}
}
运行结果如下：
Builder buildPartA()
Product doSomethingA()
Builder buildPartB()
Product doSomethingB()
Builder buildPartC()
Product doSomethingC()
Product doOtherthing()
以上就是直接省略了构建的抽象接口，直接在构建的实例对象中写完。当然了，如果应用场景不复杂，是可以这么写的，毕竟设计模式的目的就是让代码更清晰有条理，能简洁的地方不需要再复杂化。
