Effective Java in Kotlin,你的九阳神功要更新了

作者:超凶的土拨鼠

链接
https://www.jianshu.com/p/0d170f86a15f


作为Java四大名著的 Effective Java
,历来赞誉极高。随着近年来Kotlin的攻城略地,身为一名优秀Android开发的你,怎么还能囿于老的招式。很高兴 超凶的土拨鼠
同学,给我们带来的Effective Java in Kotlin。


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 (这两种类型都实现了 Kotlin
    List
     接口)。通常情况下我们要操作的是接口,隐藏在接口下的具体实现有时并不重要。简单地说,静态工厂方法可以返回超类型的任意子类型,甚至改变类型的某些实现。

  • 减少了创建参数化类型实例的冗长
    。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 method

将工厂方法放入伴生对象中的另一个好处是:我们可以定义伴生对象的扩展方法。因此我们可以给外部依赖来添加伴生工厂方法(前提是外部依赖定义了伴生对象):

interface Tool {
companion object { … }
}
fun Tool.Companion.createBigTool(…) : BigTool { … }

或者是具名的伴生对象

interface Tool {
companion object Factory { … }
}
fun Tool.Factory.createBigTool(…) : BigTool { … }

Top-level function

在 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 constructor

构造器在 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 constructo

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 objec

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

通常在大多数情况下主构造器可以满足对象创建的需求,如果需要使用其他的方式创建对象,可以考虑上述的几种方式。

Effective Java in Kotlin,你的九阳神功要更新了

关注我获取更多知识或者投稿

Effective Java in Kotlin,你的九阳神功要更新了

Effective Java in Kotlin,你的九阳神功要更新了

原文 

http://mp.weixin.qq.com/s?__biz=MzA3NzMxODEyMQ==&mid=2666456431&idx=1&sn=96b86a9c0feae4fdd2896cf63746667c

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » Effective Java in Kotlin,你的九阳神功要更新了

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址