据我们所知,有‘已知的已知’,有些事,我们知道我们知道;我们也知道,有‘已知的未知’,也就是说,有些事,我们现在知道我们不知道
-- 唐纳德·拉姆斯菲尔德
我已经使用Kotlin差不多两年了，我最开始时为了技术演讲将它用于一个实验项目。你还记得那个时候 Kotlin 使用的是 traits 而不是 interfaces ? 从写下第一行代码开始，我就知道这门语言将改变我的生活，你知道发生了什么吗？我预测的完全正确。
知识使你变得更强大，这就是为什么世界的大多数成功的工程师总是在学习新的东西。这里是我整理的5条关于 Kotlin 不那么有名的特性，我希望你会发现其中至少有3条值得你去了解。
1.命名 imports
在 Kotlin 中，import 是提供给编译器使用的，有了 import 你可以通过不完整的名称来命名类。但是如果有名称冲突的话会发生什么事情？会发生悲剧！
package com.code.sliski.userinfoscreen.ui
import ...
import android.view.View // Conflict
class UserInfoFragment : Fragment(), com.code.sliski.userinfoscreen.ui.View { // Conflict
override fun onCreateView(inflater: LayoutInflater,
container: ViewGroup?,
state: Bundle?): View = // Conflict
inflater.inflate(user_info_fragment,
container,
false)
}
interface View // Conflict
就我个人而言，我讨厌在代码中使用完整的包名，因为那样会降低代码的可读性和清晰度。在 Python 中，你可以命名 import 来解决这样的冲突问题，Kotlin 同样也支持这一功能❤。
import android.view.View as AndroidView // Named import
class UserInfoFragment : Fragment(), View {
override fun onCreateView(inflater: LayoutInflater,
container: ViewGroup?,
state: Bundle?): AndroidView = // Using named import
}
2.修改companion object 名称
Companion object 是用来替换静态成员的。它不仅可以用来声明静态属性，并且还可以给它命名。怎么实现？我们一起来看这个示例：
// Using in Java
CustomButton button = new CustomButton(context);
button.setVisibility(CustomButton.Companion.getGONE());
// Using in Kotlin
val button = CustomButton(context)
button.visibility = CustomButton.VISIBLE
class CustomButton(context: Context?) : View(context) {
companion object {
// Visibility
val GONE = 1
val VISIBLE = 2
val INVISIBLE = 3
}
}
Kotlin 默认会为每一个 companion object 创建一个静态匿名类 Companion。这就是为什么在 Java 代码中需要通过 CustomButton.Companion 来访问其静态成员（在 Kotlin 中你也可以这样访问，但是没有必要）。Kotlin 允许你将 companion object 的默认名称修改为任意名称。 将上面的代码重构一下：
// Using in Java
CustomButton button = new CustomButton(context);
button.setVisibility(CustomButton.Visibility.getGONE());
...
class CustomButton(context: Context?) : View(context) {
companion object Visibility {
val GONE = 1
val VISIBLE = 2
val INVISIBLE = 3
}
}
这里最大的缺陷是 Kotlin 不支持单个类拥有多个 companion object。 这对于分组静态属性非常有用。
val button = CustomButton(context)
button.visibility = CustomButton.Visibility.VISIBLE
button.foregroundGravity = CustomButton.ForegroundGravity.LEFT
class CustomButton(context: Context?) : View(context) {
companion object Visibility {
val VISIBLE = 1
val INVISIBLE = 2
}
companion object ForegroundGravity {
val LEFT = 1
val RIGHT = 2
}
}
这段代码不能通过编译，因为 Kotlin 仅支持一个类拥有一个 companion object
3.组合函数
我相信你使用过函数引用，但是你尝试过用他们来组合函数吗？想象一下你需要将一组价格通过税费、打折和四舍五入后映射成另外一组价格。使用普通的方法你将写出类似这样的代码：
val prices = listOf(21.8, 232.5, 231.3)
prices.map(::taxed)
.map(::discounted)
.map(::rounded)
fun taxed(value: Double): Double = value * 1.4
fun discounted(value: Double): Double = value * 0.9
fun rounded(value: Double): Double = Math.round(value).toDouble()
这个例子是为了演示函数组合，所以请不要忽视它。 Abracadabra
val prices = listOf(21.8, 232.5, 231.3)
val taxedDiscountedRounded = compose(::taxed, ::discounted, ::rounded)
prices.map(taxedDiscountedRounded)
fun <A, B> compose(f: (A) -> A,
g: (A) -> A,
h: (A) -> B): (A) -> B = { x -> h(g(f(x))) }
fun taxed(value: Double): Double = value * 1.4
fun discounted(value: Double): Double = value * 0.9
fun rounded(value: Double): Double = Math.round(value).toDouble()
函数组合不仅仅使你的代码更简洁，还会使你的代码运行的更快。一旦你理解了函数组合，你几乎可以组合出任何东西。
4.修改编译器生成类的名称
扩展函数是 Kotlin 最具吸引力的特性之一，但是在 Java 代码中使用扩展函数非常头疼。代码非常丑陋，并且看起来和调用一个静态方法没什么两样。
// Main.java
public static void main(String[] args) {
String name = null;
AnyKt.ifNull(name, new Function1<Object, Unit>() {
@Override
public Unit invoke(Object o) {
return null;
}
});
}
// Any.kt
inline fun <T> T?.ifNull(function: (T?) -> Unit) {
if (this == null) function(this)
}
Kotlin 会生成一个具有静态方法的 AnyKt 类，所以你可在 Java 代码中使用它。有一种方法可以修改生成的类的名称，从而获得更好的可读性。
// Main.java
public static void main(String[] args) {
String name = null;
Nullcheck.ifNull(name, new Function1<Object, Unit>() {
@Override
public Unit invoke(Object o) {
return null;
}
});
}
// Any.kt
@file:JvmName("Nullcheck")
package ...
inline fun <T> T?.ifNull(function: (T?) -> Unit) {
if (this == null) function(this)
}
5.赋值有效性检查以及 "veto"
Kotlin处理代理的方式非常引人注目的，如果你不是很了解，你应该先读一下我的另一篇文章Zero boilerplate delegation in Kotlin。
除了 “class delegation” 还有一种有趣的机制称为 “delegated properties”。 这种机制用于 lazy 属性的初始化。如果有一个场景是你想拦截对一个属性的赋值并且“否决（veto）”它该怎么办呢？有任何简洁的方式可以实现这个需求吗？有！
var price: Double by Delegates.vetoable(0.0) { prop, old, new ->
validate(new)
}
fun validate(price: Double) : Boolean {
// Validation checks
}
这个示例展示了内置 vetoable 代理的使用。传递给 vetoable 的 Lambda 表达式会在将新值赋值给 property之前调用。如果 lambda 返回的结果是 false，你就可“否决”这次赋值，但是如果你想通过那么就需要返回 true。
