一，定义
Builder模式是一种广泛使用的设计模式，定义是：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
经过演化，现在在Android中使用的是这个模式的一个变种。
二，经典的Builder模式
经典的Builder模式主要有四个参与者：
1.Product:被构造的复杂对象，ConcreteBuilder用来创建该对象的内部表示，并定义它的装配过程。
2.Builder:抽象接口，用来定义创建Product对象的各个组成部件的操作。
3.ConcreteBuilder：Builder接口的具体实现，可以定义多个，是实际构建Product对象的地方，同时会提供一个返回Product的接口。
4.Director：Builder接口的构造者和使用者
例子：
首先是要创建的Product类：
public class Product{
private String partOne;
private String partTwo;
public String getPartOne() {
return partOne;
}
public String getPartTwo() {
return partTwo;
}
public void setPartOne(String partOne)
{
this.partOne = partOne;
}
public void setPartTwo(String partTwo)
{
this.partTwo = partTwo;
}
}
Product类有两个参数可设置
然后是Builder接口
public interface Builder {
public void buildPartOne();
public void buildPartTwo();
public Product getProduct();
}
然后实现Builder接口，创建一个ConcreteBuilder。
public class ConcreteBuilderA implements Builder {
private Product product;
@Override
public void buildPartOne() {
}
@Override
public void buildPartTwo() {
}
@Override
public Product getProduct() {
return product;
}
}
最后是Director类
public class Director {
private Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
public void builderProduct(){
this.builder.buildPartOne();
this.builder.buildPartTwo();
}
public Product getProduct(){
return this.builder.getProduct();
}
}
三，builder模式的变种
经典的builder模式重点在于抽象创建的步骤，并通过调用不同的具体实现从而得到不同的结果，而变种的builder模式的目的在于减少对象的创建过程中引入的多个重载构造函数，可选参数以及setters过度使用导致的不必要的复杂性。
定义一个User类及其内部类UserBuilder
public class User {
private final String mFirstName; //必选
private final String mLastName; //必选
private final String mGender; //可选
private final int mAge;//可选
private final String mPhoneNo;//可选
public User(UserBuilder builder){
mFirstName=builder.mFirstName;
mLastName=builder.mLastName;
mGender=builder.mGender;
mAge=builder.mAge;
mPhoneNo=builder.mPhoneNo;
}
public String getmFirstName() {
return mFirstName;
}
public String getmLastName() {
return mLastName;
}
public String getmGender() {
return mGender;
}
public int getmAge() {
return mAge;
}
public String getmPhoneNo() {
return mPhoneNo;
}
public static class UserBuilder{
private final String mFirstName;
private final String mLastName;
private String mGender;
private int mAge;
private String mPhoneNo;
public UserBuilder(String mFirstName, String mLastName) {
this.mFirstName = mFirstName;
this.mLastName = mLastName;
}
public UserBuilder gender(String mGender){
this.mGender=mGender;
return this;
}
public UserBuilder age(int age){
this.mAge=age;
return this;
}
public UserBuilder phone(String mPhoneNo){
this.mPhoneNo=mPhoneNo;
return this;
}
public User build(){
return new User(this);
}
}
}
上面代码有几个特点：
1.User类的构造函数是私有的，意味着调用者不能直接实例化这个类
2.User类是不可变的，所有必选属性都是final的并且在构造函数中设置；同时对属性只提供getter函数。
3.UserBuilder的构造函数只接受必选的属性值作为参数，并且只有必选的属性值设置为final，以保证它们在构造函数中设置。
使用方法;
public User getUser(){
return new User.UserBuilder("a","b")
.gender("male")
.age(30)
.phone("123")
.build();
}
