Kotlin 怎么学？遇到过哪些坑？

Posted 2021-04-01 鸿洋

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Kotlin 怎么学？遇到过哪些坑？相关的知识，希望对你有一定的参考价值。

本文作者

链接：

https://www.jianshu.com/p/dcf6cd7c59a3

本文由作者授权发布。

kotlin 优势

kotlin 在 17 年 google io 大会上确定为亲儿子，android studio canary 3.0 版本开始，直接支持 kotlin 语言，不需要额外安装 as plugin。

kotlin 的出现，给 android 开发者带来了极大的活力，现在的 android 工业开发，讲究的是语法糖，效率，性能，高质量，以及可拓展性，而 kotlin 的出现给 java 开发者带来了极大的福音。

kotlin 官网教程英文

https://kotlinlang.org/docs/reference/basic-types.html

kotlin 官网教程中文

https://www.kotlincn.net/docs/reference/

阅读此文章大约半小时~

如何阅读？

浏览kotlin 优势和kotlin 坑这两大章节，然后去学习 kotlin 基础语法，根据第三章，kotlin 普及里的建议，可以在实际开发中，开干了。

避免 npl以及非空判断更优雅

kotlin 默认是非空的，如果你需要声明一个可能为空的变量，那么如下：

private  var mName:String = "kk"
private  var mSubName:String? = null

这里的 mName 变量声明为，String 类型；mSubName 声明为 String?。前者不能为 null，后者可以为 null。

然后，你可能经常在 java 中写这样的代码：

if (mANRPA != null) {
    mANRPA.stop();
}

那么在 kotlin 你这要这样写就行了：

mANRPA?.stop()

使用 ?. 的效果和上面的 java 代码是一样的，表示该变量可能为空，如果不为空则执行后面的表达式。

https://www.kotlincn.net/docs/reference/null-safety.html

java 语法完全兼容 kotlin

你可以通过几个小时学习 kotlin 的基础语法，包括：

怎么定义变量
怎么定义方法
怎么定义类
等等......

然后就可以像 java 一样使用 kotlin，当然这不是我们的最终目的，因为 kotlin 的语法糖才是我们最后的目标。

google 发布了 kotlin 简易教程，大概只需要几个小时，就可以看完：

在实际的开发中，大概第一个星期内，你写代码的速度会下降一些，但是一个星期之后，完全上手了，写代码的速度是有很大的提升的。

kotlin 高级语法(语法糖示例)

1.extension-扩展函数和扩展属性

关于扩展函数的说明：

https://www.kotlincn.net/docs/reference/extensions.html

android ktx 库提供了一系列的优秀的扩展函数官方说明

https://android.github.io/android-ktx/core-ktx/index.html

简单的说，扩展函数是什么呢？先来看一个例子，在java 里面你要 remove 一个 View 的 Parent，你可能会这样写：

if(mLoadingView.getParent() != null){
    ((ViewGroup)mLoadingView.getParent()).removeView(mLoadingView);
}

但是每次都这样写，貌似比较重复，对吧；然后你就可能考虑写一个静态方法，类似如下，比如在 ViewUtils 类似命名里写一个静态函数：

public static void removeSelf(View view){
    if(view == null) return;
    if(view.getParent() != null){
        ((ViewGroup)view.getParent()).removeView(view);
    }
}

但是在 kotlin 中，使用扩展函数，可以更巧妙更直接的实现这个功能。

写在某个文件里面，编写一个顶级的扩展函数，如下：

inline fun View.removeSelf(): Boolean {
    if (this.parent != null && this.parent is ViewGroup) {
        (this.parent as ViewGroup).removeView(this)
        return true
    }
    return false
}

然后在需要调用的地方，你直接这样写就行了：

mTopBar?.removeSelf()

当然 kotlin 扩展函数的作用并不仅仅在此，它的思想主要是丰富实际类的语法。

例如，现在让你设计一个功能，点击一个按钮，然后发起一个网络请求，但是需要注意在 View 的生命周期内，如果View 销毁了，取消这个网络请求，并且不会更新UI。那么常规的 java 代码，写起来可能就是一堆的回调，但是使用 kotlin 的扩展函数+代理，封装之后，你看到的就是下面一行代码。

//这里封装了 onClick() 方法，详细的细节，后面会介绍
mJumpBitmap.onClickAutoDisposable { 
    //这里是你的网络请求操作
}

2.Delegate And Delagate Properties -委托以及委托属性

代理在设计模式上是非常优秀的，例如 retrofit 框架里，大量的使用动态代理这种设计模式；然后 kotlin 在语法层面去支持了代理，包括代理和代理属性。

代理属性的话，kotlin 支持一些标准的代理属性,例如 by lazy，Observable,Storing;其中 by lazy，提供三种类型的懒加载，包括非线程安全，synchronized 同步线程安全，以及cas 操作线程安全。

示例如下,例如在 PushProto.java 中，需要对 ProtoBuf 解析单例进行初始化，并且要求是线程安全的，原先 java 代码如下，也就是一个 double check 的单例模式。

//double check 的单例模式，这里的 volatile 是为了防止指令重排
private static volatile com.google.protobuf.Parser<PushProto> PARSER;
//这里省略一些代码
if (PARSER == null) {    synchronized (com.yy.hiyo.proto.PushProto.class) {
   if (PARSER == null) {
       PARSER = new DefaultInstanceBasedParser(DEFAULT_INSTANCE);
            }
    }

如果是用 kotin 则只需要使用 by lazy 懒加载委托属性便能实现类似的效果，kotlin 代码如下：

//by lazy 支持泛型，后面的泛型是 initProtoInstance 的类型
val initProtoInstance by lazy<DefaultInstanceBasedParser> {
  //这里其实就是返回值
    DefaultInstanceBasedParser();
}

注意:实际上这里使用的并非是是 double check 的模式，而是类似的一种线程安全模式，源码如下：

//by lazy 默认是 SynchronizedLazyImpl 模式
public fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)

@kotlin.jvm.JvmVersion
public fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T> =
        when (mode) {
            LazyThreadSafetyMode.SYNCHRONIZED -> SynchronizedLazyImpl(initializer)
            LazyThreadSafetyMode.PUBLICATION -> SafePublicationLazyImpl(initializer)
            LazyThreadSafetyMode.NONE -> UnsafeLazyImpl(initializer)
        }

private class SynchronizedLazyImpl<out T>(initializer: () -> T, lock: Any? = null) : Lazy<T>, Serializable {
    private var initializer: (() -> T)? = initializer
    @Volatile private var _value: Any? = UNINITIALIZED_VALUE
    // final field is required to enable safe publication of constructed instance
    private val lock = lock ?: this

    override val value: T
        get() {
            val _v1 = _value
            if (_v1 !== UNINITIALIZED_VALUE) {
                @Suppress("UNCHECKED_CAST")
                return _v1 as T
            }
            return synchronized(lock) {
                val _v2 = _value
                if (_v2 !== UNINITIALIZED_VALUE) {
                    @Suppress("UNCHECKED_CAST") (_v2 as T)
                }
                else {
                    val typedValue = initializer!!()
                    _value = typedValue
                    initializer = null
                    typedValue
                }
            }
        }

    override fun isInitialized(): Boolean = _value !== UNINITIALIZED_VALUE
}

by lazy 的三种模式如下：

LazyThreadSafetyMode.SYNCHRONIZED 类似 double check 线程安全，synchronized 悲观锁
LazyThreadSafetyMode.PUBLICATION 线程安全，使用 cas 锁，多个线程可以同时执行初始化代码块，但是只返回第一个执行完成的数值，作为初始化
LazyThreadSafetyMode.NONE 单线程先可用，等于 java 懒汉式单例

其后，其它两种标准属性，参考官方教程。

3.语法层面支持懒加载-by lazy 和 lateinit

懒加载是经常使用的一个功能，传统的 java 懒加载，可能是在使用的是判断一下对象是否为空，但是在 kotlin 里，提供了语法层次的懒加载，表示该变量在使用之前一定会被初始化。

by-lazy 上面说到了，lateinit 简单用法如下：

lateinit var mStirng: String

//初始化的时候，直接赋值
mString = "some"

//使用的时候，可以先判断是否初始化
if(TestActivity::mStirng.isLateinit){
  //这里表示初始化过了
}

4.比 java 更强大的类型判断

在 java 中，泛型和反射都是使用频率极高的语法，使用泛型或者接口编程之后，我们经常要使用 instance of 做判断，如下代码：

if (instance instanceof BasePresenter) {
    ((BasePresenter) instance).onInit(mMvpContext); // 2. init
}

在kotlin 里面，只需要写如下代码：

//Any 类型，等于 java  Object 类型
fun checkSting(content:Any){
  //kotlin 用 is 判断是否一种类型，等于 instance
    if(content is String){
      //这里之后 content 会智能 转换为 String，并不需要 java 那种强转，编译器会自动识别
        content.substring(1)
    }
}

在泛型和接口编程使用广泛的情况下，kotlin 的类型安全存在以下优势：

is 操作符，支持非操作，比 java 更简洁，在语法层次表面的非该类型；其次 is 类型判断符，作用域类，类型会智能转换，也就是例子中说的。需要注意是，val 和 var 类型，支持的 is 操作不一样。
as 操作符，支持空类型转换，也就是 as？，可以转换为 String? 等可空类型，类似 java 操作是先要判断该对象是否为该类型，然后强转，语法比较绕，然而 kotlin 直接支持可为空类型的转换

5.functions and lambdas - 函数和 lambdas 表达式

在 kotlin 里面函数是第一公民，java 8 也把加入了该特性，但是远远没有 kotlin 的函数功能强大，kotlin 的函数功能如下：

参数值和变量可以是函数
函数参数支持默认参数
支持命名参数
支持 lambda
支持内联函数
支持强大的扩展函数
编译器支持内联优化
函数可以有一个接收者

函数和 lambdas 表达式对实际开发带来极大的方便，也丰富了编程思想，更多的细节，可以参考官方教程。

6.强大的集合功能

在 kotlin stdlib 里面，支持了强大的集合功能，支持各种高阶函数,主要的高阶函数如下：

分组 sort
映射 map
排序 sort
等等

具体可以参考一个专栏 kotlin 学习之路

https://zhuanlan.zhihu.com/LearningKotlin

或者可以直接在 AS 里面搜索类 _Collection.kt，里面可以看到该类的所有的高阶函数.

下面是一个简单的示例，比如你在 java 中需要对一个后端返回的 List 进行排序，java 中常见的实现方案有

1. Collections 中static <T extends Comparable<? super T>> void sort(List<T> list)传入该 List，但是 List 中的元素需要实现 Comarable 接口，并且重写 compareTo()方法

2. Collection中，static <T> void sort(List<T> list, Comparator<? super T> c) 入该 List 和一个Comparator。

3. java 中，支持 lambda 表达式之后，你可以这样写

ballList.sort(Comparator.comparing(Ball::getHits));

表示使用 Ball 的 hits 字段进行比较

4. java 8 中可以使用 stream

如果使用 kotlin，这里支持各种各样的sort() 方式，如下 api：

那么上面的例子中，kotlin 中这个排序只要使用 Collections 里面的扩展函数就可以做了。

//使用 hits 字段，做降序处理，Collections.sort() 中默认是升序的
ballList.sortByDescending {it.hits}

所以其实写到这里，我们已经见识到了，kotlin 的开发者帮助我们考虑了各种语法场景，我们站立在一个伟大的开发团队上，自然而然能更快的写出更高质量的代码。

7.Standard Lib标准库

Kotlin的标准库提供了一系列提高开发效率的函数，例如 apply{} ，run{},let{} 等，这里的解释都比较简单，具体自己看一下 api 就行了,位于 Standard.kt 文件中，使用例子如下：

EnterRoomConfig.RoomlistEventBean eventBean = new EnterRoomConfig.RoomlistEventBean();
eventBean.setColumn(String.valueOf(position + 1));
eventBean.setRow(baseRoomEventListBean.getRow());
eventBean.setPositionId(String.valueOf(position + 1));
eventBean.setToken(token);
eventBean.setModelId(baseRoomEventListBean.getModelId());

你可能不断的为访问 java bean 或者某个对象的属性或者方法，则需要不停的写对象实例.属性或者对象实例.方法。在 kotlin 中，你完全可以释放自己的双手，如下：

val enterRoomConfig = EnterRoomConfig("").apply {
  //这里有个 this 指向前面new 出来的 EnterRoomConfig() 实例
  //其实等于 this.isGuideEnter 
    isGuideEnter = false
    isQuickMatch = true
    followUid = followUid
    pwd_token = ""
}

apply() 的源码如下：

public inline fun <T> T.apply(block: T.() -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block()
    return this
}

这里包含，contract 用法和带接受者的函数，block() 函数的接收者是T，kotlin 这里其实是提供了一种方便的建造者模式，在 java 里面，你实现建造者模式，需要自己手动去编写接口和 Builder 实现，在 kotlin 则使用这些高阶函数，方便你随意的实现 Builder 模式。

8.编写单例更快了

你只需要使用 Object 就可以编写单例了，如下：

object CloUtils {
    fun test(){
    }
}

那么kotlin 上的单例和 java 的各种单例模式，性能上有什么区别吗？kotlin 使用 object 关键字声明的单例，翻译成 java 如下：