重学Kotlin之那些你没注意到的细节

本是古典何须时尚 2023-02-20 02:23 3阅读 0赞

### 前言 ###

大家好，好久不见。从Kotlin发布到现在已经有快十个年头了，从2016年发布正式版发展到现在已经有越来越多的开发者开始使用Kotlin开发项目，特别是安卓开发者，因为谷歌在2017年的 I/O 大会上正式宣布Kotlin正式成为安卓的一级开发语言，在2019年的 I/O大会上又宣布Kotlin为安卓的第一开发语言。。

我从2018年下半年开始学习的Kotlin，最开始买了一本《Kotlin从零到精通》，跟着学习了一遍，把Kotlin的基本语法学习了一遍，由于待的公司比较小，安卓开发者并不多，而且当时正好有一个新的项目，所以我提议整个项目采用Kotlin进行开发，其实当时很冒险，因为那个项目挺着急，三个安卓开发都不咋会Kotin，所以在项目开发期间一直是边学边写，项目完成之后感觉自己对Kotlin已经理解的差不多了（其实只是会用而已，项目中有的地方还是使用Java）。

后来看一些开发者论坛看大家学习Kotlin的越来越多，提到的好多东西竟然都看不懂，最过分的是已经使用kotlin写了一个项目了，Kotlin中的一些关键字都不知道是干啥用的，实在惭愧。

之前一直关注郭神的博客，而且安卓入门也看的是郭神的《第二行代码》。后来听说要出《第三行代码》，而且里面有Kotlin的详细讲解，所以书第一天发售的时候就立马抢了一本签名版，还没来的及好好看看，公司就让我出差了，一直到现在才有空看看，看了看感觉之前写的代码好多都不太好，好多Kotlin中好用的东西都没使用到，我使用的Kotlin只是把Java代码转成了Kotlin，没有一点意义。好了，下面开始知识点了，敲黑板划重点！

### Kotlin中的标准函数 ###

Kotlin中的标准函数指的是在 **Standard.kt** 中定义的函数，下面来写一下我认为经常使用的标准函数吧！

#### let ####

最开始决定使用Kotlin的时候的一个重要原因就是它把空指针异常提到了语言层面，但是这也是让很多像我一样的开发者头疼的地方。。

是，Kotlin为了空安全不允许定义为空的，想要定义的话就必须加上问号，但是。。。。很多情况就像下面的代码：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhb2ppYWdvdQ_size_16_color_FFFFFF_t_70][]

为了Kotlin的空安全必须使用问号点或者两个感叹号点来消除空安全的报错，只是为了消除报错，在Java中根本不需要的好嘛！要是只使用一次两次还好，咱们使用问号或者感叹号还好，但如果是一堆调用的呢？比如下面：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhb2ppYWdvdQ_size_16_color_FFFFFF_t_70 1][]

参数多的时候怎么搞。。不说写的速度，烦都烦死了。。。。

后来。。。。发现根本没必要这样写啊！可以这样啊：

var zhu:ZhuJ? = null
    
        fun test() { 
            zhu?.let {  zhu->
                zhu.name
                zhu.phone
                zhu.age
                zhu.sex
            }
        }

是不是瞬间感觉代码优雅了好多。。。全局变量都没问题，方法的实参更没问题了。。

知识点啊兄弟们，早知道这样就不写一堆问号和感叹号了。。。

#### with ####

这个标准函数的作用是Lambda中的代码会持有对象的上下文，其最后一行代码为返回值。

这么说不太好理解，来一段代码大家先看下吧：

operator fun String.times(n: Int): String { 
        val sb = StringBuilder()
        repeat(n){ 
            sb.append(this)
        }
        return sb.toString()
    }

这是一个String类的运算符重载的一个方法，意思很简单，就是重复字符串，参数为重复几次。大家可以发现，在这个方法中的 StringBuilder 对象被使用了好几回，没一会都需要写一次，但是。。。如果使用了with标准函数的话。。。。

operator fun String.times(n: Int): String { 
        return with(StringBuilder()) { 
            repeat(n) { 
                append(this@times)
            }
            toString()
        }
    }

是不是感觉清爽了些许，很多情况可以这样来调用。

#### run ####

这个标准函数的作用其实和 with 基本一致，只是使用方法上有所不同，with 需要括号中写入对象来进行操作，run 则是对象点进行操作，上面代码使用 run 改写之后的代码如下：

operator fun String.times(n: Int): String { 
        return StringBuilder().run { 
            repeat(n) { 
                append(this@times)
            }
            toString()
        }
    }

#### apply ####

这块要注意了，apply 使用方式和run一致，但是不同的是：最后一行不作为返回值，废话不多说，还拿上面代码改写：

operator fun String.times(n: Int): String { 
        return StringBuilder().apply { 
            repeat(n) { 
                append(this@times)
            }
        }.toString()
    }

with 和 run 的最后一行都是返回值，而apply泽不是，这块一定要注意。

### 关键字 ###

这块需要好好的总结下了，真的是，都写了一个项目了连使用语言的关键字都没认全。。一个一个来！

#### lateinit ####

这个关键字其实使用的很多，在定义全局变量为空的时候并不是非得用问号设置为可空的，如果你可以确定一定不为空可以使用 lateinit 这个关键字来定义全局变量，举个栗子：

lateinit var zhuJ: ZhuJ

当这样定义全局变量的时候就无需设置为可空了，比如安卓项目中的 adapter ，咱们肯定能确认会赋值，不会为空，那么就可以使用 lateinit 了。

这块需要注意的是，即使咱们觉得不会为空，但肯定会有特殊情况需要进行判断，需要进行判断的话要使用 isInitialized ，使用方法如下：

if (::zhuJ.isInitialized){ 
        // 判断是否已经进行赋值
    }

#### sealed ####

这个关键字之前一直没有进行使用，它用来修饰类，含义为**密封类**，之前一直没搞懂这个密封类有啥说啥用，这两天好好看了下，我理解的作用就是：可以使代码更加严密。

这样说感觉有点抽象，再举个栗子吧，平时咱们在封装一些工具的时候一般只会有成功和失败，咱们的做法一般是定义一个接口，然后再定义一个成功类和失败类来实现这个接口，最后再进行判断：

class Success(val msg: String) : Result
    class Fail(val error: Throwable) : Result
    
    fun getResult(result: Result) = when (result) { 
        is Success -> result.msg
        is Fail -> result.error.message
        else -> throw IllegalArgumentException()
    }

上面代码都是咱们一般写的，虽然只有两种情况，但是必须再写 else 来进行判断，如果不写的话编译就过不了。但如果使用密封类的话就不会有这种情况出现：

sealed class Results
    class Success(val mag: String) : Results()
    class Failure(val error: Exception) : Results()
    
    fun getMessage(result: Results) { 
        when (result) { 
            is Success -> { 
                println(result.mag)
            }
            is Failure -> { 
                println(result.error.toString())
            }
        }
    }

不仅不用再写else，而且在进行 when 判断时，kotlin 会检查条件是否包含了所有的子类，如果没有会提示你加上，这样就大大提高的代码的鲁棒性，也不会出现没有判断到的问题。

#### operator ####

这个关键字是**运算符重载**，其实在上面标准函数中已经使用到了，就是可以对运算符进行重新自定义，用来实现一些代码上不对劲但实际上对劲的需求，使用起来也很舒服。

这里来说一下咱们常用的运算符需要重载的函数吧：加号对应 **plus**、减号对应**minus**、乘号对应 **times**、除号对应 **div**、取余对应 **rem**、自增对应 **inc**、自减对应 **dec**。

具体使用方法就是上面那样，再写下吧：

operator fun String.times(n: Int): String { }

#### internal ####

这个关键字可以用来修饰类和方法，它的作用很简单，就是限制不同 module 的访问，如果在 A module 中定义了一个 internal 方法，那么这个方法只能在 A module 中进行调用，在 B module 中是无法访问的。

#### inner ####

这个关键字很简单，用来修饰类，但是。。。只能用来修饰内部类。

咱们来写个栗子大家就知道了：

class Test { 
    
        var num: String? = null
        
        class Zhu() { 
            var nums: String? = null
            fun adds() { 
                nums?.let {  it.length }
            }
        }
    
        inner class Jiang() { 
            var nums: String? = null
            fun adds() { 
                nums?.let { 
                    it.length
                }
            }
        }
    }

上面代码很简单，只是定义了一个 Test 类，其中一个是直接在内部创建的 Zhu 类，另一个是使用 inner 关键字修饰的 Jiang 类。咱们直接来调用下看下有什么区别吧：

Test().Jiang().nums
        Test.Zhu().nums

大家发现没有，如果要使用 inner 修饰内部类的话需要先获取到 Test 类的实例才可以进行使用，而直接创建的 Zhu 类则不需要。

#### inline ####

这个关键字的意思是内联函数，它的用法非常简单，只需要在高阶函数前加上 inline 关键字即可。如果对高阶函数不太清楚的，建议去看下扔物线的一个视频，好像是讲解 Lanbda 的。

简单说下吧，高阶函数并没有想象中的难，只是名字听着感觉很高大上而已，简单来说就是传入方法（其实本质上还是对象）当作方法参数即为高阶函数。高阶函数的原理其实就是把方法参数转为接口，并创建匿名内部类进行调用，所以每次调用这样的 Lambda 都会创建一个新的匿名内部类和接口实例，造成额外的开销。

所以这就是 inline 出现的原因，它可以去掉这些开销，并没有什么特殊的，只是进行替换，就是在你调用的地方把方法参数进行替换，从而减少内存和性能的开销。来看下使用方法吧：

inline fun high(block:(Int,Int) -> Int,block2:(Int,Int) -> Int){ 
        block.invoke(5,6)
        block2.invoke(4,5)
    }

#### noinline ####

诶，这个关键字和上面内联函数的关键字好像是吧！这是因为如果一个高阶函数中有两个或以上的方法参数存在的话，如果使用 inline 关键字的话会把所有的方法参数都变为内联函数，为什么不都替换呢？因为内联函数的函数类型参数在编译的时候会进行代码替换，所以没有真正的参数类型，但非内联函数的函数类型参数可以自由的传递给其他任何函数，而内联函数类型参数只允许传递给另一个内联函数。

说了这么多就是为了引出 noinline 的存在意义，使用方法很简单：

inline fun high(block:(Int,Int) -> Int,noinline block2:(Int,Int) -> Int){ 
        block.invoke(5,6)
        block2.invoke(4,5)
    }

是不是很简单，只要在方法参数前加上 noinline 关键字即可。

#### crossinline ####

既然已经说了 noinline 关键字，那么也得说下 crossnoinline 了。它的作用是：让无法使用内联函数的方法使用内联函数。

为什么有无法使用内联函数的函数呢？非内联函数无法直接 return ，但是内联函数可以，所以如果在高阶函数中创建或者使用了另外的 Lambda 或匿名类的实现的话即会报错。再举个栗子：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhb2ppYWdvdQ_size_16_color_FFFFFF_t_70 2][]

上面代码使用了咱们非常熟悉的 Runnable ，但是发现报错了，为什么呢？上面已经说出了答案，这就是 crossinline 关键字的作用，可以让无法使用内联函数的函数来使用内联函数：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhb2ppYWdvdQ_size_16_color_FFFFFF_t_70 3][]

完美解决！crossinline 的作用主要是用于保证内联函数中的 Lambda 表达式中一定不会使用 return 关键字，这样也就没有冲突了。这样也有一个坏处，就是我们也无法调用 Runnable 中使用 return 进行返回了。

#### infix ####

这个关键字其实很好用，咱们可以使用它来一些很骚的操作：

val result = "zhujiang" * 3
     val a = result begin "zhu"

是不是没见过这样的写法？复制到你电脑上肯定报错。infix 主要的作用就是定义一些语义上很舒服的写法，比如上面的 result begin “zhu” 这样的调用方式：

infix fun String.begin(prefix:String):Boolean = startsWith(prefix)

是不是很好用，是不是已经想到很多骚操作了？哈哈哈

但是！

要注意以下两点：

> 1.  infix 不能定义成顶层函数，必须是某个类的成员函数，可使用扩展方法的方式将它定义到某个类中
> 2.  infix 函数必须且只有能接收一个参数，类型的话没有限制。

#### by ####

这个关键字的意思是委托。来一个使用方法看看吧：

class MySet<T>(val help:HashSet<T>) :Set<T> by help{ 
    
        override fun isEmpty(): Boolean { 
            return false
        }
    
    }

可以为一些类创建委托类并重写或添加一些自己写的方法。

### 泛型 ###

泛型大家再熟悉不过了，Java 中咱们使用的也非常多，例如 List 、HashMap<String,String>等等。

#### kotlin中的泛型 ####

其实使用和 Java 中差不多，栗子又来了：

class Generic <T>{ 
    
        fun method(parem:T):T{ 
            return parem
        }
        
    }

上面是在类上的使用，当然方法中也可以进行使用：

fun <S> meth(parem:S):S{ 
            return parem
        }

#### 泛型的实化 ####

在 Java 中是绝对没有的，也是不现实的，因为 Java 的泛型擦出机制。。。

但是在Kotlin中是可以实现的，但是。。。。有条件！

1.  函数必须是内联函数，因为只有内联函数才有替换的操作。
2.  声明类型时必须加上 **reified** 关键字来表示该泛型要进行实化。

那么，实化有什么作用呢？来看代码吧：

inline fun <reified T> startActivity(context:Context) { 
        context.startActivity(Intent(context,T::class.java))
    }

知道了吧。。很方便的！

#### 泛型的逆变和协变 ####

这块。。。说起来有点麻烦，下一篇文章来专门写写泛型的逆变和协变吧！先欠着！

### 总结 ###

先总结到这里吧，其实 Kotlin 中还有很多好玩的东西需要我们去探索，比如协程，项目中其实用到了很多，但总感觉使用的不够好，需要有空好好扣一扣。虽然说内容并不多，但也写了好久，文中的知识都是跟着郭神的《第三行代码》学习的，也推荐大家购买，一本书能学到一个知识点就不亏，支持正版，别为了省几十块钱下载盗版。。。

如果本文对你有帮助，请别忘记三连啊。如果本文有描述不恰当或错误的地方，请提出来，感激不尽。就这样，下回见。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhb2ppYWdvdQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200622085208728.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhb2ppYWdvdQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhb2ppYWdvdQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020062208521977.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhb2ppYWdvdQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhb2ppYWdvdQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200622085306921.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhb2ppYWdvdQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhb2ppYWdvdQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200622085318755.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhb2ppYWdvdQ==,size_16,color_FFFFFF,t_70