剑网3指尖江湖职业推荐 www.1468054.com


原文: 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所代表的意思就不明確,你可以認為它是數組的第一個元素或者是數組的大小?;蛔鍪薔蔡こХ椒?code>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, getTypenewType, 這些都是很常見的靜態工廠方法的命名。

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

在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標準庫。ListMutableList是接口,他們并沒有構造器,但是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

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

作者:超兇的土撥鼠

余下全文(1/3)

本文最初發表在www.jianshu.com,文章內容屬作者個人觀點,不代表本站立場。

分享這篇文章:

請關注我們:

發表評論

電子郵件地址不會被公開。 必填項已用*標注