用 Kotlin 开发 Android 项目的感受

Posted 2020-09-20 白乾涛

原文：http://www.jianshu.com/p/8a1fce6fa93a 和 http://www.jianshu.com/p/b444aea1b038

空指针安全

简单一点的例子，那就是 String 和 String？ 是两种不同的类型。String 已经确定是不会为空，一定有值；而 String？则是未知的，也许有值，也许是空。在使用对象的属性和方法的时候，String 类型的对象可以毫无顾忌的直接使用，而 String？类型需要你先做非空判断。

fun demo() {
    val string1: String = "string1"
    val string2: String? = null
    val string3: String? = "string3"
    println(string1.length) //7
    println(string2?.length)  //null
    println(string3?.length)  //7
}

尽管 string2 是一个空对象，也并没有因为我调用了它的属性/方法就报空指针。而你所需要做的，仅仅是加一个"?"。

转型与智能转换

我写过这样子的 JAVA 代码

if(view instanceof TextView) {
    TextView textView = (TextView) view;
    textView.setText("text");
}

而在 Kotlin 中的写法则有所不同

if(view is TextView) {
    TextView textView = view as TextView
    textView.setText("text")
}

缩减代码之后对比更加明显

if(view instanceof TextView) {
    ((TextView) view).setText("text");
}

if(view is TextView) {
    (view as TextView).setText("text")
}

相比于 JAVA 在对象前加 (Class) 这样子的写法，Kotlin 是在对象之后添加 as Class 来实现转型。

至少我个人而言，在习惯了 as Class 顺畅的写法之后，是再难以忍受 JAVA 中前置的写法，哪怕有 cast 快捷键的存在，仍然很容易打断我写代码的顺序和思路

事实上，Kotlin 此处可以更简单：

if(view is TextView) {
    view.setText("text")
}

因为当前上下文已经判明 view 就是 TextView，所以在当前代码块中 view 不再是 View 类，而是 TextView 类。这就是 Kotlin 的智能转换。

接着上面的空安全来举个例子，常规思路下，既然 String 和 String? 是不同的类型，是不是我有可能会写出这样的代码？

val a: A? = A()
if (a != null) {
    println(a?.b)
}

这样子写，Kotlin 反而会给你显示一个高亮的警告，说这是一个不必要的 safe call。至于为什么，因为你前面已经写了 a != null 了啊，于是 a 在这个代码块里不再是 A? 类型, 而是 A 类型。

智能转换还有一个经常出现的场景，那就是 switch case 语句中。在 Kotlin 中，则是 when 语法。

fun testWhen(obj: Any) {
    when(obj) {
        is Int -> {
            println("obj is a int")
            println(obj + 1)
        }
        is String -> {
            println("obj is a string")
            println(obj.length)
        }
        else -> {
            println("obj is something i don‘t care")
        }
    }
}
fun main(args: Array<String>) {
    testWhen(98)
    testWhen("98")
}

可以看出，在已经判断出是 String 的条件下，原本是一个 Any 类的 obj 对象，我可以直接使用属于 String 类的 .length 属性。

Kotlin 的智能程度远不止如此，即便是现在，在编写代码的时候还会偶尔蹦一个高亮警告出来，这时候我才知道原来我的写法是多余的，Kotlin 已经帮我处理了好了。

比 switch 更强大的 when

通过上面智能转化的例子，已经展示了一部分 when 的功能。但相对于 JAVA 的 switch，Kotlin 的 when 带给我的惊喜远远不止这么一点。

例如：

fun testWhen(int: Int) {
    when(int) {
        in 10 .. Int.MAX_VALUE -> println("${int} 太大了我懒得算")
        2, 3, 5, 7 -> println("${int} 是质数")
        else -> println("${int} 不是质数")
    }
}
fun main(args: Array<String>) {
    (0..10).forEach { testWhen(it) }
}

输出如下：

0 不是质数
1 不是质数
2 是质数
3 是质数
4 不是质数
5 是质数
6 不是质数
7 是质数
8 不是质数
9 不是质数
10 太大了我懒得算

和 JAVA 中死板的 switch-case 语句不同，在 when 中，我既可以用参数去匹配 10 到 Int.MAX_VALUE 的区间，也可以去匹配 2, 3, 5, 7 这一组值，当然我这里没有列举所有特性。when 的灵活、简洁，使得我在使用它的时候变得相当开心（和 JAVA 的 switch 对比的话）

容器的操作符

自从迷上 RxJava 之后，我实在很难再回到从前，这其中就有 RxJava 中许多方便的操作符。而 Kotlin 中，容器自身带有一系列的操作符，可以非常简洁的去实现一些逻辑。

例如:

(0 until container.childCount)
        .map { container.getChildAt(it) }
        .filter { it.visibility == View.GONE }
        .forEach { it.visibility = View.VISIBLE }

上述代码首先创建了一个 0 到 container.childCount - 1 的区间；

再用 map 操作符配合取出 child 的代码将这个 Int 的集合转化为了 childView 的集合；

然后在用 filter 操作符对集合做筛选，选出 childView 中所有可见性为 GONE 的作为一个新的集合；

最终 forEach 遍历把所有的 childView 都设置为 VISIBLE。

这里再贴上 JAVA 的代码作为对比。

for(int i = 0; i < container.childCount - 1;  i++) {
    View childView = container.getChildAt(i);
    if(childView.getVisibility() == View.GONE) {
        childView.setVisibility(View.VISIBLE);
    }
}

这里就不详细的去描述这种链式的写法有什么优点了。

线程切换

既然上面提到了 RxJava，不得不想起 RxJava 的另一个优点——线程调度。Kotlin 中有一个专为 android 开发量身打造的库，名为 anko，其中包含了许多可以简化开发的代码，其中就对线程进行了简化。

async {
    val response = URL("https://www.baidu.com").readText()
    uiThread {
        textView.text = response
    }
}

上面的代码很简单，通过 async 方法将代码实现在一个异步的线程中，在读取到 http 请求的响应了之后，再通过 uiThread 方法切换回 ui 线程将 response 显示在 textView 上。

抛开内部的实现，你再也不需要为了一个简简单单的异步任务去写一大堆的无效代码。

一个关键字实现单例

没错，就是一个关键字就可以实现单例：

object Log {
    fun i(string: String) {
        println(string)
    }
}
fun main(args: Array<String>) {
    Log.i("test")
}

再见，单例模式

自动getter/setter及class简洁声明

JAVA 中类的标准写法下，一个属性对应了 get 和 set 两个方法，需要手动写的代码量相当大。

而 Kotlin 中是这样的：

class Person(var name: String)
val person = Person("张三");

还可以添加默认值：

class Person(var name: String = "张三")
val person = Person()

再附上项目中一个数据类：

data class Column(
        var subId: String?,
        var subTitle: String?,
        var subImg: String?,
        var subContentnum: Int?,
)

一眼望去，没有多余代码。这是为什么我认为 Kotlin 代码比 JAVA 代码要更容易写得干净的原因之一。

DSL 式编程

说起 dsl ，Android 开发者接触的最多的或许就是 gradle 了

例如：

android {
    compileSdkVersion 23
    buildToolsVersion "23.0.2"
    defaultConfig {
        applicationId "com.zll.demo"
        minSdkVersion 15
        targetSdkVersion 23
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile(‘proguard-android.txt‘), ‘proguard-rules.pro‘
        }
    }
}

这就是一段 Groovy 的 DSL，用来声明编译配置

那么在 Android 项目的代码中使用 DSL 是一种什么样的感觉呢？

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    val homeFragment = HomeFragment()
    val columnFragment = ColumnFragment()
    val mineFragment = MineFragment()
    setContentView(
            tabPages {
                backgroundColor = R.color.white
                dividerColor = R.color.colorPrimary
                behavior = ByeBurgerBottomBehavior(context, null)
                tabFragment {
                    icon = R.drawable.selector_tab_home
                    body = homeFragment
                    onSelect { toast("home selected") }
                }
                tabFragment {
                    icon = R.drawable.selector_tab_search
                    body = columnFragment
                }
                tabImage {
                    imageResource = R.drawable.selector_tab_photo
                    onClick { showSheet() }
                }
                tabFragment {
                    icon = R.drawable.selector_tab_mine
                    body = mineFragment
                }
            }
    )
} 

没错，上面的代码就是用来构建这个主界面的 viewPager + fragments + tabBar 的。以 tabPages 作为开始，设置背景色，分割线等属性；再用 tabFrament 添加 fragment + tabButton，tabImage 方法则只添加 tabButton。所见的代码都是在做配置，而具体的实现则被封装了起来。

前面提到过 anko 这个库，其实也可以用来替代 xml 做布局用：

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    verticalLayout {
        textView {
            text = "这是标题"
        }.lparams {
            width = matchParent
            height = dip(44)
        }
        textView {
            text = "这是内容"
            gravity = Gravity.CENTER
        }.lparams {
            width = matchParent
            height = matchParent
        }
    }
}

相比于用 JAVA 代码做布局，这种 DSL 的方式也是在做配置，把布局的实现代码封装在了背后，和 xml 布局很接近。

委托/代理

通过 Kotlin 中的委托功能，我们能轻易的写出一个 SharedPreference 的代理类

class Preference<T>(val context: Context, val name: String?, val default: T) : ReadWriteProperty<Any?, T> {
    val prefs by lazy {
        context.getSharedPreferences("xxxx", Context.MODE_PRIVATE)
    }
    override fun getValue(thisRef: Any?, property: KProperty<*>): T = with(prefs) {
        val res: Any = when (default) {
            is Long -> {
                getLong(name, 0)
            }
            is String -> {
                getString(name, default)
            }
            is Float -> {
                getFloat(name, default)
            }
            is Int -> {
                getInt(name, default)
            }
            is Boolean -> {
                getBoolean(name, default)
            }
            else -> {
                throw IllegalArgumentException("This type can‘t be saved into Preferences")
            }
        }
        res as T
    }
    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) = with(prefs.edit()) {
        when (value) {
            is Long -> putLong(name, value)
            is String -> putString(name, value)
            is Float -> putFloat(name, value)
            is Int -> putInt(name, value)
            is Boolean -> putBoolean(name, value)
            else -> {
                throw IllegalArgumentException("This type can‘t be saved into Preferences")
            }
        }.apply()
    }
}

暂且跳过原理，我们去看怎么使用

class EntranceActivity : BaseActivity() {
    private var userId: String by Preference(this, "userId", "")
    override fun onCreate(savedInstanceState: Bundle?) {
        testUserId()
    }
    fun testUserId() {
        if (userId.isEmpty()) {
            println("userId is empty")
            userId = "default userId"
        } else {
            println("userId is $userId")
        }
    }
}

重复启动 app 输出结果：

userId is empty

userId is default userId

userId is default userId

...

第一次启动 app 的时候从 SharedPreference 中取出来的 userId 是空的，可是后面却不为空。由此可见，userId = "default userId" 这句代码成功的将 SharedPreference 中的值修改成功了。

也就是说，在这个 Preference 代理的帮助下，SharedPreference 存取操作变得和普通的对象调用、赋值一样的简单。

扩展，和工具类说拜拜

很久很久以前，有人和我说过，工具类本身就是一种违反面向对象思想的东西。可是当时我就想了，你不让我用工具类，那有些代码我该怎么写呢？直到我知道了扩展这个概念，我才豁然开朗。

fun ImageView.displayUrl(url: String?) {
    if (url == null || url.isEmpty()) {
        imageResource = R.mipmap.ic_launcher
    } else {
        Glide.with(context)
                .load(ColumnServer.SERVER_URL + url)
                .into(this)
    }
}
...
val imageView = findViewById(R.id.avatarIv) as ImageView
imageView.displayUrl(url)

上述代码可理解为：

• 我给 ImageView 这个类扩展了一个名为 displayUrl 的方法，这个方法接收一个名为 url 的 String？类对象。如不出意外，会通过 Glide 加载这个 url 的图片，显示在当前的 imageView 上；
  
• 我在另一个地方通过 findViewById 拿到了一个 ImageView 类的实例，然后调用这个 imageView 的displayUrl 方法，试图加载我传入的 url
  

通过扩展来为 ImageView 添加方法，相比于通过继承 ImageView 来写一个 CustomImageView，再添加方法而言，侵入性更低，不需要在代码中全写 CustomImageView，也不需要在 xml 布局中将包名写死，造成移植的麻烦。

这事用工具类当然也可以做，比如做成 ImageUtil.displayUrl(imageView, url)，但是工具类阅读起来并没有扩展出来的方法读起来更自然更流畅。

扩展是 Kotlin 相比于 JAVA 的一大杀器

向 findViewById 说 NO

不同于 JAVA 中，在 Kotlin 中 findViewById 本身就简化了很多，这得益于 Kotlin 的类型推断以及转型语法后置：

val onlyTv = findViewById(R.id.onlyTv) as TextView

很简洁，但若仅仅是这样，想必大家会喷死我：就这么点差距也拿出来搞事？

当然不是。在官方库 anko 的支持下，这事又有了很多变化。

例如

val onlyTv = find<TextView>(R.id.onlyTv)
val onlyTv: TextView = find(R.id.onlyTv)

肯定有人会问：find 是个什么鬼？

让我们点过去看看 find 的源码：

inline fun <reified T : View> Activity.find(id: Int): T = findViewById(id) as T

忽略掉其他细节，原来和我们上面第一种写法没差别嘛，不就是用一个扩展方法给 Activity 加了这么一个方法，帮我们写了 findViewById，再帮我们转型了一下嘛。其实 Kotlin 中很多令人乍舌的实现都是在一些基础特性的组合之上实现的。

在 anko 的帮助下，你只需要根据布局的 id 写一句 import 代码，然后你就可以把布局中的 id 作为 view 对象的名称直接使用。不仅 activity 中可以这样玩，你甚至可以 viewA.viewB.viewC，所以大可不必担心 adapter 中应当怎么写。

import kotlinx.android.synthetic.main.activity_main.*
...
onlyTv.text="不需要声明直接可以用"

也许有的朋友会发现这和 Google 出品的 databinding 实在是有异曲同工之妙，那如果我告诉你，databinding 库本身就有对 kotlin 的依赖呢？

简单粗暴的 startActivity

我们原本为了 startActivity，不得不 new 一个 Intent 出来，特别是当我要传递参数的时候：

Intent intent = new Intent(LoginActivity.this, MainActivity.class);
intent.putExtra("name", "张三");
intent.putExtra("age", 27);
startActivity(intent);

不知道大家有木有累觉不爱？

在 anko 的帮助下，startActivity 是这样子的：

startActivity<MainActivity>()
startActivity<MainActivity>("name" to "张三", "age" to 27)
startActivityForResult<MainActivity>(101, "name" to "张三", "age" to 27)

无参情况下，只需要在调用 startActivity 的时候加一个 Activity 的 Class 泛型来告知要到哪去。

有参也好说，这个方法支持你传入 vararg params: Pair<String, Any>

有没有觉得代码写起来、读起来流畅了许多？

玲珑小巧的 toast

JAVA 中写一个 toast 大概是这样子的：

Toast.makeText(context, "this is a toast", Toast.LENGTH_SHORT).show();

不得不说真的是又臭又长，虽然确实是有很多考量在里面，但是对于使用来说实在是太不便利了，而且还很容易忘记最后一个 show()。我敢说没有任何一个一年以上的 Android 开发者会不去封装一个 ToastUtil 的。

让我们看看 anko 是怎么做的了：

context.toast("this is a toast")

如果当前已经是在 context 上下文中（比如 activity）:

toast("this is a toast")

如果你是想要一个长时间的 toast：

longToast("this is a toast")

没错，就是给 Context 类扩展了 toast 和 longToast 方法，用屁股想都知道里面干了什么。只是这样一来比任何工具类都来得更简洁更直观。

用 apply 方法进行数据组合

假设有如下 A、B、C 三个 class：

class A(val b: B)
class B(val c: C)
class C(val content: String)

可以看到，A 中有 B，B 中有 C。在实际开发的时候，我们有的时候难免会遇到比这个更复杂的数据，嵌套层级很深。这种时候，用 JAVA 初始化一个 A 类数据会变成一件非常痛苦的事情。例如：

C c = new C("content");
B b = new B(c);
A a = new A(b);

这还是 A、B、C 的关系很单纯的情况下，如果有大量数据进行组合，那么我们会需要初始化大量的对象进行赋值、修改等操作。如果我描述的不够清楚的话，大家不妨想一想用 JAVA 代码布局是一种什么样的感觉？

当然，在 JAVA 中也是有解决方案的，比如使用 Builder 模式来进行相应配置。（说到这里，其实用 Builder 模式基本上也可以说是 JAVA 语言的 DSL）

但是在更为复杂的情况下，即便是有设计模式的帮助，也很难保证代码的可读性。那么 Kotlin 有什么好方法来解决这个问题吗？

Kotlin 中有一个名为 apply 的方法，它的源码是这样子的：

@kotlin.internal.InlineOnly
public inline fun <T> T.apply(block: T.() -> Unit): T { block(); return this }

没有 Kotlin 基础的小伙伴看到这里一定会有点晕。我们先忽略一部分细节，把关键的信息提取出来，再改改格式看看：

public fun <T> T.apply(block: T.() -> Unit): T {
    block()
    return this
}

• 首先，我们可以看出 T 是一个泛型，而且后面没有给 T 增加约束条件，那么这里的 T 可以理解为：我这是在给所有类扩展一个名为【apply】的方法；
  
• 第一行最后的【: T】表明，我最终是要返回一个 T 类，其实就是返回调用方法的这个对象自身；
  
• 在 return this 之前，我执行了一句 block()，这意味着 block 本身一定是一个方法。我们可以看到，apply 方法接收的 block 参数的类型有点特殊，不是 String 也不是其他什么明确的类型，而是【T.() -> Unit】；
  
• 【T.() -> Unit】表示的意思是：这是一个上下文在 T 对象中，返回一个 Unit 类对象的方法。由于 Unit 和 JAVA 中的 Void 一致，所以可以理解为不需要返回值。

那么这里的 block 的意义就清晰起来了：一个执行在 T，即调用 apply 方法的对象自身当中，又不需要返回值的方法。

有了上面的解析，我们再来看一下这句代码：

val textView = TextView(context).apply {
    text = "这是文本内容"
    textSize = 16f
}

这句代码就是初始化了一个 TextView，并且在将它赋值给 textView 之前，将自己的文本、字体大小修改了。

或许你会觉得这和 JAVA 比起来并没有什么优势。别着急，我们慢慢来：

layout.addView(TextView(context).apply {
    text = "这是文本内容"
    textSize = 16f
})

这样又如何呢？我并不需要声明一个变量或者常量来持有这个对象才能去做修改操作。

上面的A、B、C 问题用 Kotlin 来实现是可以这么写的：

val a = A().apply {
    b = B().apply {
        c = C("content")
    }
}

我只声明了一个 a 对象，然后初始化了一个 A，在这个初始化的对象中先给 B 赋值，然后再提交给了 a。B 中的 C 也是如此。当组合变得复杂的时候，我也能保持我的可读性。说到底，这个小技巧也就是 ①扩展方法 + ②高阶函数 两个特性组合在一起实现的效果。

null