[翻译]Effective Java in Kotlin:1. 考虑用静态工厂方法而不是构造器

原文: 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

一般在大多数状况下主构造器能够知足对象建立的需求，若是须要使用其余的方式建立对象，能够考虑上述的几种方式。