阅读完需：约 4 分钟
Builder模式理解
比如说你需要构造一个机器：是不是会包含很多部件，但是根据相同的制造过程可以制作出不同的机器（机器猫，机器狗，机器人，机器等等）。再比如说相同的注册流程可以注册出不同的公司（百度，华为，小米等等），不同的注册信息可以表示出不同的公司。
然后我们再说说为什么要用Builder模式吧，比如你做个机器人，我们是不是要用很多参数（手，脚，关节，眼睛，嘴巴，鼻子等等）来构造，如果你用一般的构造方法，你觉得你要写多少个构造方法呢？显得特别麻烦，代码还不清晰，传参也麻烦；这样我们就引入了Builder模式。
关键点在于，你要制造的机器人也许所有的关节都要，也许仅仅只要手或脚就可以了，也有可能要其他的，有非常多的选择，所以要使用Builder模式，你要什么就造什么。
Builder模式简单示例
步骤一：
创建一个实体类CompanyClient，里面有个和实体类（只能获取变量值）相同变量的静态内部类Builder（设置变量值） 。在实体类通过构造函数来构造一个Builder，通过调用build（）来建造一个具体的实体对象。
/**
* 实体类 包含一个静态内部类 Builder
*/
public class CompanyClient {
public final String companyName;
public final String companyAddress;
public final double companyRegfunds;
public final String mPerson;
public final String mType;
//构造方法
public CompanyClient() {
this(new Builder());
}
//构造方法
public CompanyClient(Builder builder){
this.companyName = builder.companyName;
this.companyAddress = builder.companyAddress;
this.companyRegfunds = builder.companyRegfunds;
this.mPerson = builder.person;
this.mType = builder.type;
}
public String getCompanyName() {
return companyName;
}
public String getCompanyAddress() {
return companyAddress;
}
public double getCompanyRegfunds() {
return companyRegfunds;
}
public String getmPerson() {
return mPerson;
}
public String getmType() {
return mType;
}
public Builder newBuilder() {
return new Builder(this);
}
@Override
public String toString() {
return "CompanyClient{" +
"companyName='" + companyName + '\'' +
", companyAddress='" + companyAddress + '\'' +
", companyRegfunds=" + companyRegfunds +"千万"+
", mPerson=" + mPerson +
", mType='" + mType + '\'' +
'}';
}
/**
*静态内部类 Builder
*/
public static class Builder{
public String companyName;
public String companyAddress;
public double companyRegfunds;
public String person;
public String type;
//构造方法
public Builder() {
companyName = companyName;
companyAddress = companyAddress;
companyRegfunds = companyRegfunds;
person = person;
type = type;
}
//构造方法
Builder(CompanyClient companyClient){
this.companyName = companyClient.companyName;
this.companyAddress = companyClient.companyAddress;
this.companyRegfunds = companyClient.companyRegfunds;
this.person = companyClient.mPerson;
this.type = companyClient.mType;
}
public Builder setCompanyName(String name) {
companyName = name;
return this;
}
public Builder setCompanyAddress(String address) {
companyAddress = address;
return this;
}
public Builder setCompanyRegfunds(double regfunds) {
companyRegfunds = regfunds;
return this;
}
public Builder setmPerson(String per) {
person = per;
return this;
}
public Builder setmType(String typeStr) {
type = typeStr;
return this;
}
//构建一个实体
public CompanyClient build() {
return new CompanyClient(this);
}
}
}
步骤二：
实现类(TestBuilder)
public class TestBuilder {
public static void main(String[] args) {
CompanyClient client = new CompanyClient.Builder()
.setCompanyName("百度")
.setCompanyAddress("海定区百度大厦")
.setCompanyRegfunds(5)
.setmPerson("1000人以上")
.build();
System.out.println("构造出一个公司：" + client.toString());
System.out.println("---------------------分隔符");
CompanyClient.Builder builder = new CompanyClient.Builder();
builder.setCompanyName("华为");
builder.setCompanyAddress("海定区百度大厦");
builder.setCompanyRegfunds(20);
builder.setmType("通信科技行业");
CompanyClient client1 = builder.build();
System.out.println("构造出另一个公司：" + client1.toString());
}
}
效果：
代码的关键点：
我先创建一个你想要的，所有东西的集合类，Builder ，然后在 Builder 里面加入你所需要的内容，最后将 Builder 类打包起来返回去，给最外层的类 CompanyClient 来处理就可以了。
Kotlin 版
简化：
/**
* 实体类 包含一个静态内部类 Builder
*/
class CompanyClient @JvmOverloads constructor(builder: Builder = Builder()) {
val companyName: String
val companyAddress: String
val companyRegfunds: Double
val mPerson: String
val mType: String
//构造方法
init {
companyName = builder.companyName
companyAddress = builder.companyAddress
companyRegfunds = builder.companyRegfunds
mPerson = builder.person
mType = builder.type
}
override fun toString(): String {
return """
CompanyClient{
companyName='${companyName}',
companyAddress='${companyAddress},
companyRegfunds='${companyRegfunds}千万,
mPerson='${mPerson},
mType='${mType}
}
""".trimIndent()
}
/**
* 静态内部类 Builder
*/
class Builder {
var companyName: String = "null"
var companyAddress: String = "null"
var companyRegfunds: Double = 0.0
var person: String = "null"
var type: String = "null"
//构造方法
constructor() { }
fun setCompanyName(name: String): Builder {
companyName = name
return this
}
fun setCompanyAddress(address: String): Builder {
companyAddress = address
return this
}
fun setCompanyRegfunds(regfunds: Double): Builder {
companyRegfunds = regfunds
return this
}
fun setmPerson(per: String): Builder {
person = per
return this
}
fun setmType(typeStr: String): Builder {
type = typeStr
return this
}
//构建一个实体
fun build(): CompanyClient {
return CompanyClient(this)
}
}
}
fun main(args: Array<String>) {
val client = CompanyClient.Builder()
.setCompanyName("百度")
.setCompanyAddress("海定区百度大厦")
.setCompanyRegfunds(5.0)
.setmPerson("1000人以上")
.build()
println("构造出一个公司：$client")
println("---------------------分隔符")
val builder = CompanyClient.Builder()
builder.setCompanyName("华为")
builder.setCompanyAddress("海定区百度大厦")
builder.setCompanyRegfunds(20.0)
builder.setmType("通信科技行业")
val client1 = builder.build()
println("构造出另一个公司：$client1")
}
