[[348621]]

 其實這個問題很多人都進行過解答，也有很多小伙伴在Java四大名著之一的《Effective Java》中的第1～5小節了解過，不過我還是想結合自己的理解對這個問題進行總結和歸納，談談為什么會最終選擇構建器來實現我們的目的。

在 Java 中有多種方式可以創建對象，總結起來主要有下面的 4 種方式：

正常創建：通過 new 操作符

反射創建：調用 Class 或 java.lang.reflect.Constructor 的 newInstance()方法

克隆創建：調用現有對象的 clone()方法

發序列化：調用 java.io.ObjectInputStream 的 getObject()方法反序列化

Java 對象的創建方式是其語法明確規定，用戶不可能從外部改變的。本文仍然要使用上面的方式來創建對象，所以本文只能說是構建對象，而非創建對象也。

假設有這樣一個場景，現在要構建一個大型的對象，這個對象包含許多個參數的對象，有些參數有些是必填的，有些則是選填的。那么如何構建優雅、安全地構建這個對象呢?

01 單一構造函數

通常，我們第一反應能想到的就是單一構造函數方式。直接 new 的方式構建，通過構造函數來傳遞參數，見下面的代碼：

/*** 
* 單一構造函數 
*/ 
public class Person { 
// 姓名（必填） 
private String name; 
// 年齡（必填） 
private int age; 
// 身高（選填） 
private int height; 
// 畢業學校（選填） 
private String school; 
// 愛好（選填） 
private String hobby; 
public Person(String name, int age, int height, String school, String hobby) { 
this.name = name; 
this.age = age; 
this.height = height; 
this.school = school; 
this.hobby = hobby; 
} } 

上面的構建方式有下面的缺點：

有些參數是可以選填的（如 height, school），在構建 Person 的時候必須要傳入可能并不需要的參數。

現在上面才 5 個參數，構造函數就已經非常長了。如果是 20 個參數，構造函數都可以直接上天了！

構建的這樣的對象非常容易出錯。

客戶端必須要對照 Javadoc 或者參數名來講實參傳入對應的位置。如果參數都是 String 類型的，一旦傳錯參數，編譯是不會報錯的，但是運行結果卻是錯誤的。

02 多構造函數

對于第 1 個問題，我們可以通過構造函數重載來解決。見下面的代碼：

/*** 
* 多構造函數 
*/ 
public class Person { 
// 姓名（必填） 
private String name; 
// 年齡（必填） 
private int age; 
// 身高（選填） 
private int height; 
// 畢業學校（選填） 
private String school; 
// 愛好（選填） 
private String hobby; 
public Person(String name, int age) { 
this.name = name; 
this.age = age; 
} 
public Person(String name, int age, int height) { 
this.name = name; 
this.age = age; 
this.height = height; 
} 
public Person(String name, int age, int height, String school) { 
this.name = name; 
this.age = age; 
this.height = height; 
this.school = school; 
} 
public Person(String name, int age, String hobby, String school) { 
this.name = name; 
this.age = age; 
this.hobby = hobby; 
this.school = school; 
} } 

上面的方式確實能在一定程度上降低構造函數的長度，但是卻有下面的缺陷：

導致類過長。這種方式會使得 Person 類的構造函數成階乘級增長。按理來說，應該要寫的構造函數數是可選成員變量的組合數（實際并沒有這么多，原因見第 2 點）。如果讓我調用這樣的類，絕對會在心里默念 xx!!

有些參數組合無法重構。因為 Java 中重載是有限制的，相同方法簽名的方法不能構成重載，編譯時無法通過。譬如包含（name, age, school）和(name, age, hobby)的構造函數是不能重載的，因為 shcool 和 hobby 同為 String 類型。Java 只認變量的類型，管你變量是什么含義呢。

03 JavaBean方式

上面的方法不行，莫急！還有法寶——JavaBean。一個對象的構建通過多個方法來完成。直接見下面的代碼：

public class Person { 
// 姓名（必填） 
private String name; 
// 年齡（必填） 
private int age; 
// 身高（選填） 
private int height; 
// 畢業學校（選填） 
private String school; 
// 愛好（選填） 
private String hobby; 
public Person(String name, int age) { 
this.name = name; 
this.age = age; 
} 
public void setHeight(int height) { 
this.height = height; 
} 
public void setSchool(String school) { 
this.school = school; 
} 
public void setHobby(String hobby) { 
this.hobby = hobby; 
} } 
客戶端使用這個對象的代碼如下： 
public class Client { 
public static void main(String[] args) { 
Person person = new Person("james", 12); 
person.setHeight(170); 
person.setHobby("reading"); 
person.setSchool("xxx university"); 
} } 

這樣看起來完美的解決了 Person 對象構建的問題，使用起來非常優雅便捷。確實，在單一線程的環境中這確實是一個非常好的構建對象的方法，但是如果是在多線程環境中仍有其致命缺陷。在多線程環境中，這個對象不能安全地被構建，因為它不是不可變對象。一旦Person 對象被構建，我們隨時可通過 setXXX()方法改變對象的內部狀態。假設有一個線程正在執行與 Person 對象相關的業務方法，另外一個線程改變了其內部狀態，這樣得到莫名其妙的結果。由于線程運行的無規律性，使得這問題有可能不能重現，這個時候真的就只能哭了。

04 Builder方式

為了完美地解決這個問題，下面引出本文中的主角（等等等等！）。我們使用構建器（Builder）來優雅、安全地構建 Person 對象。廢話不說，直接代碼：

/** 
* 待構建的對象。該對象的特點： 
* <ol> 
* <li>需要用戶手動的傳入多個參數，并且有多個參數是可選的、順序隨意</li> 
* <li>該對象是不可變的（所謂不可變，就是指對象一旦創建完成，其內部狀態不可變， 
更通俗的說是其成員變量不可改變）。* 不可變對象本質上是線程安全的。</li> 
* <li>對象所屬的類不是為了繼承而設計的。</li> 
* </ol> 
* 滿足上面特點的對象的構建可是使用下面的 Build 方式構建。這樣構建對象有下面的好 
處： 
* <ol> 
* <li>不需要寫多個構造函數，使得對象的創建更加便捷</li> 
* <li>創建對象的過程是線程安全的</li> 
* </ol> 
* @author xiaoyu 
* @date 2020-10-25 
*/ 
public class Person { 
// 姓名（必填），final 修飾 name 一旦被初始化就不能再改變，保證了對象的不可變 
性。 
private final String name; 
// 年齡（必填） 
private final int age; 
// 身高（選填） 
private final int height; 
// 畢業學校（選填） 
private final String school; 
// 愛好（選填） 
private final String hobby; 
/** 
* 這個私有構造函數的作用： 
* <ol> 
* <li>成員變量的初始化。final 類型的變量必須進行初始化，否則無法編譯成功</li> 
* <li>私有構造函數能夠保證該對象無法從外部創建，并且 Person 類無法被繼承</li> 
* </ol> 
*/ 
private Person(String name, int age, int height, String school, String hobby) { 
this.name = name; 
this.age = age; 
this.height = height; 
this.school = school; 
this.hobby = hobby; 
} 
/** 
* 要執行的動作 
*/ 
public void doSomething() { 
// TODO do what you want!! 
} 
/** 
* 構建器。為什么 Builder 是內部靜態類？ 
* <ol> 
* <li>必須是 Person 的內部類。否則，由于 Person 的構造函數私有，不能通過 new 的 
方式創建 Person 對象</li> 
* <li>必須是靜態類。由于 Person 對象無法從外部創建，如果不是靜態類，則外部無 
法引用 Builder 對象。</li> 
* </ol> 
* <b>注意</b>：Builder 內部成員變量要與 Person 的成員變量保持一致。 
* @author xiaoyu 
* 
*/ 
public static class Builder { 
// 姓名（必填）。注意：這里不能是 final 的 
private String name; 
// 年齡（必填） 
private int age; 
// 身高（選填） 
private int height; 
// 畢業學校（選填） 
private String school; 
// 愛好（選填） 
private String hobby; 
public Builder(String name, int age) { 
this.name = name; 
this.age = age; 
} 
public Builder setHeight(int height) { 
this.height = height; 
return this; 
} 
public Builder setSchool(String school) { 
this.school = school; 
return this; 
} 
public Builder setHobby(String hobby) { 
this.hobby = hobby; 
return this; 
} 
/** 
* 構建對象 
* @return 返回待構建的對象本身 
*/ 
public Person build() { 
return new Person(name, age, height, school, hobby); 
} } } 

客戶端構建對象的方式見下面的代碼：

/** 
* 使用 Person 對象的客戶端 
* @author xiaoyu 
* @date 2020-10-25 
*/ 
public class Client { 
public static void main(String[] args) { 
/* 
* 通過鏈式調用的方式創建 Person 對象，非常優雅！ 
*/ 
Person person = new Person.Builder("james", 12) 
.setHeight(170) 
.setHobby("reading") 
.build(); 
person.doSomething(); 
} } 

如果不想看代碼，可看下面對于上面代碼的總結：

通過 private Person(..)使得 Person 類不可被繼承

通過將 Person 類的成員變量設置為 final 類型，使得其不可變

通過 Person 內部的 static Builder 類來構建 Person 對象

通過將 Builder 類內部的 setXXX()方法返回 Builder 類型本身，實現鏈式調用構建 Person 對 象

總結

至此，我們就相對完美地解決這一類型的對象創建問題！下面來總結一下本文的重點。待創建的對象特點：

需要用戶手動的傳入多個參數，并且有多個參數是可選的、順序任意

對象不可變

對象所屬的類不是為了繼承而設計的。即類不能被繼承

依次使用的對象構建方法：

單一構造函數

多構造函數

JavaBean 方式

Builder 方式

最終，通過比較得出 Builder 方法最為合適的解決。