[翻譯]Effective Java in Kotlin:1. 考慮用靜態工廠方法而不是構造器

超凶的土撥鼠發表於2019-02-17
JavaKotlin

原文: Effective Java in Kotlin, item 1: Consider static factory methods instead of constructors

Book reminder

Effective Java 的第一條規則：開發者應該考慮用靜態工廠方法而不是構造器。靜態工廠方法指使用靜態方法來生成類的例項。下面是Java中靜態工廠方法使用示例：

Boolean trueBoolean = Boolean.valueOf(true);
String number = String.valueOf(12);
List<Integer> list = Arrays.asList(1, 2, 4);
複製程式碼

靜態工廠方法使用來改造構造器的有力方法，下面是一些使用靜態工廠方法的好處：

  • 與構造器不同，靜態工廠方法是具名的。 方法名解釋了例項是如何被建立的以及引數是什麼。舉個例子new ArrayList(3) 中3所代表的意思就不明確，你可以認為它是陣列的第一個元素或者是陣列的大小。換做是靜態工廠方法ArrayList.withSize(3),表達的意思就非常明確。具名方法的一個好處是：它解釋了引數的含義或者在某種程度上揭示了例項被建立的機制。另一個好處是解決了相同引數型別的構造方法之間的混淆。
  • 與構造器不同，靜態工廠方法並不是每次被呼叫都會建立新的例項。當我們使用靜態工廠方法時可以使用快取機制去優化例項的建立，從而提高例項建立的效能。同樣我們可以定義類似Connectrions.createOrNull()這樣的方法，使其在Connection不能建立時返回null
  • 與構造器不同，靜態工廠方法可以返回任一子型別。這一特性可以用來在不同情況下提供更合適的例項，幫助我們隱藏介面背後的真正例項。在Kotlin中所有的集合都隱藏在介面背後。比如listOf(1,2,3), 當執行在Kotlin/JVM平臺時會返回ArrayList，當執行在Kotlin/JS平臺時會返回JavaScript array （這兩種型別都實現了KotlinList介面）。通常情況下我們要操作的是介面，隱藏在介面下的具體實現有時並不重要。簡單地說，靜態工廠方法可以返回超型別的任意子型別，甚至改變型別的某些實現。
  • 減少了建立引數化型別例項的冗長。Kotlin在某種程度上解決了這個問題，因為Kotlin有更好的型別推斷。

Joshua Bloch 指出了靜態工廠方法的一些缺點：

  • 靜態工廠方法不能被用於子類的構造。在子類的構造中需要使用超類的構造器，而我們並不能使用靜態工廠方法去替代
  • 靜態工廠方法不容易和其他靜態方法進行區分。比如valueOf, of, getInstance, newInstance, getType 和 newType， 這些都是很常見的靜態工廠方法的命名。

直觀的結論： 當構造方法和例項本身結構具有很強的關聯時應該使用構造器；反之，應該使用靜態工廠方法

在Kotlin當中， Kotlin改變了靜態工廠方法的實現途徑。

Companion factory method

Kotlin中不允許靜態方法，Java中的靜態工廠方法在Kotlin中通常被伴生工廠方法(Companion factory method)所取代。伴生工廠方法指被放入伴生物件中的工廠方法：

class MyList {
    //...
    companion object {
        fun of(vararg i: Int) { /*...*/ }
    }
}
複製程式碼

使用方法和靜態工廠方法相同：

MyList.of(1,2,3,4)
複製程式碼

實際上伴生物件是一個單例類，這就導致了伴生物件是可以繼承其他類的。這樣我們就可以實現多個通用的工廠方法然後給他們提供不同的類。Provider類是一個輕量的用於依賴注入的類：

abstract class Provider<T> {
    var original: T? = null
    var mocked: T? = null
    abstract fun create(): T
    fun get(): T = mocked ?: original ?: create().apply { original = this }
    fun lazyGet(): Lazy<T> = lazy { get() }
}
複製程式碼

對於不同的類，只需要提供特定的構造方法：

interface UserRepository {
    fun getUser(): User
    companion object: Provider<UserRepository> {
        override fun create() = UserRepositoryImpl()
    }
}
複製程式碼

然後我們就可以使用UserReposiroty.get()來獲取例項，或者使用val user by UserRepository.lazyGet()進行懶載入。另外還可以宣告特定的實現用於測試或進行Mock

UserRepository.mocked = object: UserRepository { /*...*/ }
複製程式碼

相比於Java來講這是一個巨大的優勢，在Java中靜態工廠方法必須在每個類中手動實現。另外一種複用工廠方法的方式是通過介面代理(interface delegation)，我們可以以如下的方式使用上述例子：

interface Dependency<T> {
    var mocked: T?
    fun get(): T
    fun lazyGet(): Lazy<T> = lazy { get() }
}
abstract class Provider<T>(val init: ()->T): Dependency<T> {
    var original: T? = null
    override var mocked: T? = null
     
    override fun get(): T = mocked ?: original ?: init()
          .apply { original = this }
}
interface UserRepository {
    fun getUser(): User
    companion object: Dependency<UserRepository> by Provider({
        UserRepositoryImpl() 
    }) 
}
複製程式碼

Extension factory methods

將工廠方法放入伴生物件中的另一個好處是：我們可以定義伴生物件的擴充套件方法。因此我們可以給外部依賴來新增伴生工廠方法（前提是外部依賴定義了伴生物件）：

interface Tool {
   companion object { … }
}
fun Tool.Companion.createBigTool(…) : BigTool { … }
複製程式碼

或者是具名的伴生物件

interface Tool {
   companion object Factory { … }
}
fun Tool.Factory.createBigTool(…) : BigTool { … }
複製程式碼

Top-level functions

在Kotlin中，使用頂層方法（Top-level functions）來取代伴生工廠方法也很常見，比如listOf,setOf,mapOf。 庫的設計者也經常提供頂層方法來建立例項。舉個例子，Android開發中，傳統的方法是使用靜態方法去建立Activity Intent:

// Java
class MainActivity extends Activity {
    static Intent getIntent(Context context) {
        return new Intent(context, MainActivity.class);
    }
}
複製程式碼

在kotlin Anko庫中，我們使用頂層方法intentFor

intentFor<MainActivity>()
複製程式碼

使用頂層方法的問題在於，公有的頂層方法是到處可以訪問的，很容易就“汙染了”IDE的智慧提示。

儘管使用公有的頂層方法需要謹慎，對於一些小的經常需要建立的例項（比如List Map）使用頂層方法是一個很好的選擇，因為listOf(1,2,3)要比List.of(1,2,3)更簡單更具有可讀性。

Fake constructors

構造器在Kotlin中的使用方式和頂層方法類似(Kotlin中不需要new關鍵字)：

class A()
val a = A()
複製程式碼

構造器可以和頂層方法以一樣的方式被引用：

val aReference = ::A
複製程式碼

構造器和方法的唯一區別在於：構造器的首字母需要大寫。這一事實被應用於很多地方甚至是Kotlin標準庫。List和MutableList是介面，他們並沒有構造器，但是Kotlin的使用者們希望可以：

List(3) { "$it" } // same as listOf("0", "1", "2")
複製程式碼

這就是為什麼下面的方法出現在Collections.kt :

public inline fun <T> List(size: Int, init: (index: Int) -> T): List<T> = MutableList(size, init)

public inline fun <T> MutableList(size: Int, init: (index: Int) -> T): MutableList<T> {
    val list = ArrayList<T>(size)
    repeat(size) { index -> list.add(init(index)) }
    return list
}
複製程式碼

Fake constructors看起來像是構造器，用法和表現也是構造器，然而很多開發者並沒有意識到他們並不是構造器而是頂層方法。同時Fake constructors還具有靜態工廠方法的優勢：可以返回子型別，並不需要每次呼叫生成新的例項；同時沒有構造器的種種限制。比如次構造器（secondary constructor）必須馬上呼叫主構造器（primary constructor）或者超類的構造器。當我們使用fake constructors時還可以推遲構造器的使用：

fun ListView(config: Config) : ListView {
    val items = … // Here we read items from config
    return ListView(items) // We call actual constructor
}
複製程式碼

Primary constructor

Kotlin引入了主構造器（primary constructor）這一概念。一個Kotlin類中只能存在一個主構造器（Kotlin中稱類似Java中的構造器為次構造器）。主構造器中的引數可以在整個類的建立中使用：

class Student(name: String, surname: String) {
    val fullName = "$name $surname"
}
複製程式碼

主構造器中的引數可以被直接定義為類的屬性：

class Student(val name: String, val surname: String) {
    val fullName 
        get() = "$name $surname"
}
複製程式碼

當主構造器包含預設引數時，重疊構造器（Telescoping Constructor）不再被需要。

Other ways to create an object

Kotlin中的工廠方法並不是Kotlin提升例項建立的唯一方式。下篇文章我們會討論Kotlin是如何提升builder pattern。舉個例子，允許DSL出現在物件建立過程中：

val dialog = alertDialog {
    title = "Hey, you!"
    message = "You want to read more about Kotlin?"
    setPositiveButton { makeMoreArticlesForReader() }
    setNegativeButton { startBeingSad() }
}
複製程式碼

Conclusion

在Kotlin中我們可以使用這些方式的同時，保留靜態工廠方法的優點：

  • Companion factory method
  • Top-level function
  • Fake constructor
  • Extension factory method

通常在大多數情況下主構造器可以滿足物件建立的需求，如果需要使用其他的方式建立物件，可以考慮上述的幾種方式。

相關文章