• Android开发基础——Kotlin简介

    什么是Kotlin

    Java代码在运行前需要编译生成一种特殊的class文件，然后Java虚拟机会识别并解释这些class文件，而Kotlin作为一种新的编程语言，就是将其代码同样编译生成为这样的class文件，也就是说，虽然看起来是两者是两种不同的编程语言，但其实其实质都是一样的。

    如何运行Kotlin代码

    运行Kotlin代码大致存在三种方法：

    • 使用IDEA工具，创建Kotlin项目，然后就可以运行Kotlin代码
    • 在线运行Kotlin代码
    • 使用Android Studio，虽然Android Studio创建的是Android项目，但是只要编写Kotlin的main函数，仍然可以独立运行Kotlin代码

    这里便使用Android Studio运行Kotlin代码。

    如在MainActivity的同级包结构下创建一个Kotlin文件，然后编写HelloWorld：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     println("Hello world!")
    5. }

    在Android Studio的run中输出结果为：

    Hello world!

    不过这里编译中途报了一个错：

    Manifest merger failed with multiple errors, see logs

    这是因为sdk和Kotlin编译器版本不匹配，解决版本：

    • 在file-setting-system setting-android sdk中下载低版本的sdk，比如Android 11(api 30)
    • 然后在build.gradle中，将compileSdk和targetSdk的参数修改为30

    变量和函数

    变量

    在Kotlin中定义一个变量，只允许在变量前声明两种关键字：

    • var：value，用于声明一个不可变的变量，这种变量在初始赋值之后就不能重新赋值，对应Java中的final变量
    • var：variable，用于声明一个可变的变量，这种变量在初始赋值之后仍可以重新赋值，对应Java中的非final变量

    比如，这样的代码是合理的：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     val a = 10
    5.     var b = 20
    6.     b = 30
    7.     println("a =" + a + ",b = " + b)
    8. }

    这是因为Kotlin采用了类型推导机制，但如果要对一个变量延迟赋值的话，就需要显式声明变量类型：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     val a = 10
    5.     var b: Int
    6.     b = 30
    7.     println("a =" + a + ",b = " + b)
    8. }

    此时也就限定了变量b只能为Int类型，而不能使用其它类型的值进行赋值。

    同时从上面可以看到，Kotlin的变量类型Int是大写的，这与Java不同，这也就意味着Kotlin中变量采用的对象数据类型，即Int是一个类，其它数据类型也是类似的，也需要大写。

    函数

    Kotlin中函数的语法规则为：

    1. fun func(param1:Int, param2:Int):Int {
    2.     return 0
    3. }

    其形式为：

    • fun：为定义函数的关键字
    • func：为函数名
    • param1:Int：为参数声明格式，前边为参数名，后边为参数类型
    • Int：最后的Int为返回值类型，这部分是可选的

    比如，下面的代码就简单说明了函数的使用：

    1. package com.example.helloworld
    2.  
    3. import kotlin.math.max
    4.  
    5. fun Larger(num1:Int, num2:Int):Int {
    6.     return max(num1, num2)
    7. }
    8.  
    9. fun main() {
    10.     val a = 10
    11.     var b: Int
    12.     b = 30
    13.     println("Larger =" + Larger(a,b))
    14. }

    同时上面的形式还可以使用Kotlin中的语法糖形式。当一个函数中只有一行代码时，Kotlin中可以不用编写函数体，而将唯一的一行代码写在函数定义的末尾。比如上面的代码就可以转化为：

    1. package com.example.helloworld
    2.  
    3. import kotlin.math.max
    4.  
    5. //fun Larger(num1:Int, num2:Int):Int = max(num1, num2)
    6. fun Larger(num1:Int, num2:Int) = max(num1, num2)
    7.  
    8. fun main() {
    9.     val a = 10
    10.     var b: Int
    11.     b = 30
    12.     println("Larger =" + Larger(a,b))
    13. }

    逻辑控制

    if条件语句

    Kotlin中的条件语句主要有两种实现形式：if语句和when语句。

    先看一下if条件语句：

    1. package com.example.helloworld
    2.  
    3. import kotlin.math.max
    4.  
    5. fun Larger(num1:Int, num2:Int):Int {
    6.     if (num1 > num2) {
    7.         return num1
    8.     } else {
    9.         return num2
    10.     }
    11. }
    12.  
    13. fun main() {
    14.     val a = 10
    15.     var b: Int
    16.     b = 30
    17.     println("Larger =" + Larger(a,b))
    18. }

    而Kotlin中的if语句还有一个额外的功能，就是if语句是可以有返回值的，返回值就是if语句每一个条件中最后一行代码的返回值。因此，上面的代码可以写为：

    1. package com.example.helloworld
    2.  
    3. import kotlin.math.max
    4.  
    5. fun Larger(num1:Int, num2:Int):Int {
    6.     return if (num1 > num2) {
    7.         num1
    8.     } else {
    9.         num2
    10.     }
    11. }
    12.  
    13. fun main() {
    14.     val a = 10
    15.     var b: Int
    16.     b = 30
    17.     println("Larger =" + Larger(a,b))
    18. }

    即可以使用if语句来为return提供返回值，或者是为变量赋值。

    而采用之前提到的语法糖的形式，又可以将代码变为：

    1. package com.example.helloworld
    2.  
    3. import kotlin.math.max
    4.  
    5. fun Larger(num1:Int, num2:Int):Int = if (num1 > num2) num1 else num2
    6.  
    7. fun main() {
    8.     val a = 10
    9.     var b: Int
    10.     b = 30
    11.     println("Larger =" + Larger(a,b))
    12. }

    when条件语句

    when条件语句有点像是Java中的switch语句。

    1. package com.example.helloworld
    2.  
    3. import kotlin.math.max
    4.  
    5. fun getScore(name:String) = if (name == "Tom") {
    6.     86
    7. } else if (name == "Jim") {
    8.     77
    9. } else if(name == "Jack") {
    10.     95
    11. } else {
    12.     0
    13. }
    14.  
    15. fun main() {
    16.     println("Score =" + getScore("Tom"))
    17. }

    上面的代码使用when条件语句就是：

    1. package com.example.helloworld
    2.  
    3. import kotlin.math.max
    4.  
    5. fun getScore(name:String) = when (name) {
    6.     "Tom" -> 86
    7.     "Jim" -> 77
    8.     "Jack" -> 95
    9.     else -> 0
    10. }
    11.  
    12. fun main() {
    13.     println("Score =" + getScore("Tom"))
    14. }

    而当执行逻辑只有一行代码时，{}可以省略。

    同时when语句还允许进行类型匹配：

    1. package com.example.helloworld
    2.  
    3. import kotlin.math.max
    4.  
    5. fun checkNumber(num:Number) {
    6.     when (num){
    7.         is Int -> println("num is Int")
    8.         is Double -> println("num is Double")
    9.         else -> println("no support")
    10.     }
    11. }
    12.  
    13. fun main() {
    14.     checkNumber(10.1)
    15. }

    同时还可以使用when的不带参数的用法：

    1. package com.example.helloworld
    2.  
    3. import kotlin.math.max
    4.  
    5. fun getScore(name:String) = when  {
    6.     name == "Tom" -> 86
    7.     name == "Jim" -> 77
    8.     name == "Jack" -> 95
    9.     else -> 0
    10. }
    11.  
    12. fun main() {
    13.     println("Score =" + getScore("Tom"))
    14. }

    循环语句

    Kotlin中循环语句也存在两种形式，while循环和for循环。

    不过Kotlin中的while循环和Java中的while循环使用方法类似，这里只说明for循环。

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     for (i in 1..10) {
    5.         println(i)
    6.     }
    7. }

    在上面的for循环中，1..10是区间的形式，即[1, 10]。可以看出这里的for循环和Java中的for循环形式还是有区别的。

    但如果需要区间[1, 10)的话，就是下边的形式：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     for (i in 1 until 10) {
    5.         println(i)
    6.     }
    7. }

    而如果要修改步长的话，就是下边的形式：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     for (i in 1 until 10 step 2) {
    5.         println(i)
    6.     }
    7. }

    而如果需要一个降序的闭区间，就是下边的形式：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     for (i in 10 downTo 1) {
    5.         println(i)
    6.     }
    7. }

    面向对象编程

    类与对象

    1. package com.example.helloworld
    2.  
    3. class Person {
    4.     var name = ""
    5.     var age = 0
    6.  
    7.     fun printInfo() {
    8.         println("name is " + name + ",age is " + age)
    9.     }
    10. }
    11.  
    12. fun main() {
    13.     var tmp = Person()
    14.     tmp.name = "Tom"
    15.     tmp.age = 15
    16.  
    17.     tmp.printInfo()
    18. }

    从上面来看，Kotlin中类的定义和实例化和Java是类似的，只是去掉了new关键字。

    继承和构造函数

    这里先看一个继承的简单示例：

    1. package com.example.helloworld
    2.  
    3. open class Person {
    4.     var name = ""
    5.     var age = 0
    6.  
    7.     fun printInfo() {
    8.         println("name is " + name + ",age is " + age)
    9.     }
    10. }
    11.  
    12. class Student:Person() {
    13.     var grade = 0
    14. }
    15.  
    16.  
    17. fun main() {
    18.     var tmp = Student()
    19.     tmp.name = "Tom"
    20.     tmp.age = 15
    21.     tmp.grade = 3
    22. }

    在上面的继承中，存在两个和Java代码不同的地方：

    • open关键字：用该关键字声明该类是可继承的，这是因为Kotlin中默认类是final的，即不可继承的，因此需要首先声明该类是可以被继承的
    • 继承形式：Java中使用extends关键字来表示继承关系，而Kotlin中使用冒号:来表示继承，同时还需要在父类后添加括号

    上面只是Kotlin中继承的简单示例，这里再看一下构造函数。Kotlin中构造函数分为两种：主构造函数和次构造函数。

    主构造函数没有函数体，直接定义再类名后面，每个类默认都会有一个不带参数的主构造函数，用户也可以为其显式指明参数。

    1. package com.example.helloworld
    2.  
    3. open class Person {
    4.     var name = ""
    5.     var age = 0
    6.  
    7.     fun printInfo() {
    8.         println("name is " + name + ",age is " + age)
    9.     }
    10. }
    11.  
    12. class Student(val grade:Int):Person() {
    13. }
    14.  
    15.  
    16. fun main() {
    17.     var tmp = Student(10)
    18.     tmp.name = "Tom"
    19.     tmp.age = 15
    20. }

    上面直接在构建Student对象时就进行了属性赋值，而如果需要在主构造函数中编写一些代码，就需要init结构体：

    1. class Student(val grade:Int):Person() {
    2.     init {
    3.         println("grade is " + grade)
    4.     }
    5. }

    这里就可以解释为什么Kotlin类继承中父类后需要存在括号。根据继承特性的规定，子类的构造函数必须调用父类的构造函数，可是主构造函数并没有函数体，因此Kotlin中的子类主构造函数通过括号指定调用父类的哪个构造函数。

    也即上面的内容中，表示Student类的主构造函数在初始化时会调用person类的无参构造函数，即使在午餐的情况下，该括号也不可省略。

    1. package com.example.helloworld
    2.  
    3. open class Person(val name:String, val age:Int) {
    4.     fun printInfo() {
    5.         println("name is " + name + ",age is " + age)
    6.     }
    7. }
    8.  
    9. class Student(name:String, age:Int, val grade:Int):Person(name, age) {
    10.     init {
    11.         println("grade is " + grade)
    12.     }
    13. }
    14.  
    15. fun main() {
    16.     var tmp = Student("Tom", 10,3)
    17. }

    上面的形式就可以调用父类的有参构造形式，不过需要保证父类存在该形式。

    而在Student类的参数声明中，也没有将父类的参数声明为val，这是因为在主构造函数中声明为val或var的参数将自动称为该类的字段，会导致冲突。因此Student中name和age的声明前不用加任何关键字，使其作用域限定在主构造函数中。

    而次构造函数在一个类中可以存在多个，次构造函数也可以用于实例化一个类，这点和主构造函数没有什么不同，只是次构造函数是有函数体的。

    Kotlin规定，当一个类既有主构造函数又有次构造函数时，所有的次构造函数都必须调用主构造函数(间接调用)：

    1. package com.example.helloworld
    2.  
    3. open class Person(val name:String, val age:Int) {
    4.     fun printInfo() {
    5.         println("name is " + name + ",age is " + age)
    6.     }
    7. }
    8.  
    9. class Student(name:String, age:Int, val grade:Int):Person(name, age) {
    10.     init {
    11.         println("grade is " + grade)
    12.     }
    13.  
    14.     constructor(name:String, age:Int):this(name, age, 0) {
    15.     }
    16.  
    17.     constructor():this("",0) {
    18.     }
    19. }
    20.  
    21. fun main() {
    22.     var tmp = Student("Tom", 10,3)
    23. }

    从上面可以看到，次构造函数是通过sonstructor关键字来定义的，上面定义了两个次构造函数，又通过次构造函数调用了主构造函数，完成了类对象的实例化。

    而当类中只有次构造函数，没有主构造函数时：

    1. package com.example.helloworld
    2.  
    3. open class Person(val name:String, val age:Int) {
    4.     fun printInfo() {
    5.         println("name is " + name + ",age is " + age)
    6.     }
    7. }
    8.  
    9. class Student:Person {
    10.     constructor(name:String, age:Int):super(name, age) {
    11.     }
    12.  
    13.     constructor():super("",0) {
    14.     }
    15. }
    16.  
    17. fun main() {
    18.     var tmp = Student()
    19. }

    比如上面的代码，Student没有显式定义主构造函数，但是存在两个次构造函数，即此时没有主构造函数，而既然子类没有主构造函数，继承父类时就不需要加上括号了。而由于没有主构造函数，次构造函数只能直接调用父类的构造函数，因此也就使用了super关键字。

    接口

    1. package com.example.helloworld
    2.  
    3. interface Study {
    4.     fun readBook()
    5.     fun doHomework()
    6. }
    7.  
    8. open class Person(val name:String, val age:Int) {
    9.     fun printInfo() {
    10.         println("name is " + name + ",age is " + age)
    11.     }
    12. }
    13.  
    14. class Student(name:String, age:Int, val grade:Int):Person(name, age), Study {
    15.     init {
    16.         println("grade is " + grade)
    17.     }
    18.     override fun readBook() {
    19.         println(name + " is reading.")
    20.     }
    21.  
    22.     override fun doHomework() {
    23.         println(name + " is doing Homework.")
    24.     }
    25. }
    26.  
    27. fun doStudy(study: Study) {
    28.     study.readBook()
    29.     study.doHomework()
    30. }
    31.  
    32. fun main() {
    33.     var tmp = Student("Tom", 10,3)
    34.     doStudy(tmp)
    35. }

    上面的代码中，定义了父类和接口，并在子类中继承了父类，实现了接口。Java中继承使用extends关键，接口实现使用implements关键字，而Kotlin中统一使用逗号分隔。同时接口后面不需要添加括号，因为其没有构造函数调用。

    子类接口中方法的实现要使用override关键字来声明，而在main中调用doStudy，doStudy接口Study接口的形式，然后调用接口中函数，这个过程就叫做多态。

    同时Kotlin中还支持对接口的默认实现：

    1. package com.example.helloworld
    2.  
    3. interface Study {
    4.     fun readBook()
    5.     fun doHomework() {
    6.         println("do homework default implements")
    7.     }
    8. }
    9.  
    10. open class Person(val name:String, val age:Int) {
    11.     fun printInfo() {
    12.         println("name is " + name + ",age is " + age)
    13.     }
    14. }
    15.  
    16. class Student(name:String, age:Int, val grade:Int):Person(name, age), Study {
    17.     init {
    18.         println("grade is " + grade)
    19.     }
    20.     override fun readBook() {
    21.         println(name + " is reading.")
    22.     }
    23. }
    24.  
    25. fun doStudy(study: Study) {
    26.     study.readBook()
    27.     study.doHomework()
    28. }
    29.  
    30. fun main() {
    31.     var tmp = Student("Tom", 10,3)
    32.     doStudy(tmp)
    33. }

    上面接口的定义中，doHomework中存在函数体，因为接口实现只会强制要求实现readBook，而不会要求强制实现doHomework，这样子类Student调用的就是接口的默认实现了。

    在上面的代码中，并不对属性和方法进行隔离，即没有使用可见性修饰符对其变量和方法进行修饰，而Java中存在public，private，protected和default四种修饰符来实现封装和隔离。

    在Kotlin中，也存在四种修饰符，分别是public，private，protected和internal，需要使用哪种修饰符时，直接在fun关键字前定义即可。

    • private：表示只对当前类内部可见
    • public：表示对所有类都可见，public是Kotlin中的默认项
    • protected：表示只对当前类和子类可见
    • internal：表示只对同一模块中的类可见

    数据类和单例类

    在项目开发中，数据类通常需要重写equals，hashCode，toString等方法，但其实这些代码具有极高的重复性。

    而在Kotlin中，创建数据类可以直接使用如下代码：

    1. package com.example.helloworld
    2.  
    3. data class Cellphone(val brand:String, val price:Double)
    4.  
    5. fun main() {
    6.     val Cellphone1 = Cellphone("HW", 5648.5)
    7.     val Cellphone2 = Cellphone("HW", 5648.5)
    8.     println(Cellphone1)
    9.     println(Cellphone1 == Cellphone2)
    10. }

    在上面的代码中，使用data来声明一个类会自动生成equals，hashCode，toString等方法，以减少重复性的开发工作。

    同时当一个类中没有任何代码时，可以省略末尾的大括号。

    而在Kotlin中，创建单例类的方式也很简单，只需要将class关键字修改为object关键字即可：

    1. package com.example.helloworld
    2.  
    3. object Singleton {
    4.     fun singletonTest() {
    5.         println("Test")
    6.     }
    7. }
    8. fun main() {
    9.     Singleton.singletonTest()
    10. }

    上面的代码也就实现了单例模式，Kotlin会自动创建一个Singleton的实例，并保证全局只会存在一个Singleton实例。

    Lambda

    集合的创建与遍历

    如果用户想要创建一个字符串列表的实例，可能需要构建ArrayList，然后逐个添加字符串，但是这种方式可能比较麻烦，而Kotlin专门提供了内置的listOf函数来简化该过程：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     var tmp = listOf("apple","banana","orange")
    5.     for(item in tmp) {
    6.         println(item)
    7.     }
    8. }

    上面的代码就使用了listOf来创建字符串列表，然后通过for循环逐个进行打印。不过listOf函数创建的是一个不可变的集合，即只可用于读取，而无法修改。

    而如果需要创建可以修改的集合，就需要使用mutableListOf函数：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     var tmp = mutableListOf("apple","banana","orange")
    5.     tmp.add("pear")
    6.     for(item in tmp) {
    7.         println(item)
    8.     }
    9. }

    上面提到的是List的用法，而Set集合的用法大致类似，不过函数名换为了setOf和mutableSetOf。不过Set集合中存放的都是唯一元素，即不存在重复元素。

    而Map的添加之前是先创建HashMap的实例，然后将键值对数据添加到Map中，而Kotling同样可以使用map["key"] = value的形式直接赋值：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     var tmp = HashMapInt>()
    5.     tmp["apple"] = 10
    6.     tmp["banana"] = 20
    7.     tmp["orange"] = 30
    8.  
    9.     for ((key, value) in tmp) {
    10.         println("key is " + key + ",value is " + value)
    11.     }
    12. }

    这样的写法看起来也有点麻烦，在Kotlin中还可以使用mapOf和mutableMapOf函数来简化该过程：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     var tmp = mapOf("apple" to 10, "banana" to 20, "orange" to 30)
    5.  
    6.     for ((key, value) in tmp) {
    7.         println("key is " + key + ",value is " + value)
    8.     }
    9. }

    这样看起来就简洁多了。

    集合的函数式API

    这里主要看一下Lambda表达式的语法结构。

    比如要查找列表中字符串最长的元素：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     var tmp = listOf("apple","banana","orange")
    5.     var maxLengthFruit = ""
    6.  
    7.     for (item in tmp) {
    8.         if (item.length > maxLengthFruit.length) {
    9.             maxLengthFruit = item
    10.         }
    11.     }
    12.  
    13.     println("max length fruit is " + maxLengthFruit)
    14. }

    上面的代码可以实现，但是如果使用集合的函数式API，则有：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     var tmp = listOf("apple","banana","orange")
    5.     var maxLengthFruit = tmp.maxByOrNull { it.length }
    6.  
    7.     println("max length fruit is " + maxLengthFruit)
    8. }

    通俗来讲，Lambda是一小段可以作为参数传递的代码，其语法结构为：

    {param1:type,param2:type -> func}

    上面定义中：

    • param：表示传入参数
    • type：表示参数类型
    • func：表示函数体

    比如上面的代码，其本质为：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     var tmp = listOf("apple","banana","orange")
    5.     var lambda = {fruit:String -> fruit.length}
    6.     var maxLengthFruit = tmp.maxByOrNull(lambda)
    7.  
    8.     println("max length fruit is " + maxLengthFruit)
    9. }

    即maxByOrNull是一个普通的函数，其可接收一个Lambda形式的参数，并且在遍历集合时将每次遍历的值作为参数传递到Lambda表达式，然后找到其最大值。

    上面的代码当然也可以这样写：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     var tmp = listOf("apple","banana","orange")
    5.     var maxLengthFruit = tmp.maxByOrNull({fruit:String -> fruit.length})
    6.  
    7.     println("max length fruit is " + maxLengthFruit)
    8. }

    而Kotlin规定，当Lambda参数式函数的最后一个参数时，可以将Lambda表达式移到函数括号的外面：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     var tmp = listOf("apple","banana","orange")
    5.     var maxLengthFruit = tmp.maxByOrNull(){fruit:String -> fruit.length}
    6.  
    7.     println("max length fruit is " + maxLengthFruit)
    8. }

    而如果Lambda表达式是函数唯一的参数，可以将函数括号省略：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     var tmp = listOf("apple","banana","orange")
    5.     var maxLengthFruit = tmp.maxByOrNull{fruit:String -> fruit.length}
    6.  
    7.     println("max length fruit is " + maxLengthFruit)
    8. }

    而Kotlin又存在类型推导机制，因此Lambda表达式中的参数列表多数情况下可以不必声明参数类型：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     var tmp = listOf("apple","banana","orange")
    5.     var maxLengthFruit = tmp.maxByOrNull{fruit -> fruit.length}
    6.  
    7.     println("max length fruit is " + maxLengthFruit)
    8. }

    而当Lambda表达式的参数列表中只有一个参数时，也不必声明参数名，而是可以使用it关键字代替：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     var tmp = listOf("apple","banana","orange")
    5.     var maxLengthFruit = tmp.maxByOrNull{it.length}
    6.  
    7.     println("max length fruit is " + maxLengthFruit)
    8. }

    这样也就形成了最初的形式。

    这里再看几个其它的API：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     println(listOf("apple","banana","orange").map{it.uppercase()})
    5.     println(listOf("apple","banana","orange").filter{it.length > 5})
    6.     println(listOf("apple","banana","orange").any{it.length > 5})
    7.     println(listOf("apple","banana","orange").all{it.length > 5})
    8. }
    • map：用来将列表进行映射转换
    • filter：用来对列表进行条件过滤
    • any：判断列表是否存在元素满足条件
    • all：判断列表是否全部元素满足条件

    Java函数式API的使用

    如果在Kotlin代码中调用了Java方法，并且该方法接收一个Java单抽象方法接口参数，就可以使用函数式API。Java单抽象方法接口指接口中只有一个待实现方法，如果接口中存在多个待实现方法，则无法使用函数式API。

    比如Java原生API中有一个常见的单抽象方法接口Runnable，该接口存在一个待实现的run方法：

    1. public interface Runnable {
    2.     void run();
    3. }

    而之前提到，对于任何一个Java方法，只要其接收Runnable参数，就可以使用函数式API。而Runnable主要是结合线程一块使用的，这里通过Java的线程类Thread来看一下：

    1. new Thread(new Runnable() {
    2.     @Override
    3.     public void run() {
    4.         System.out.println("Thread is running!")
    5.     }
    6. }).start();

    上面采用了匿名类的写法，创建了Runnable接口的匿名类实例，并将之传递给Thread类的构造方法，然后调用Thread类的start方法执行该线程。

    而写成Kotlin代码，则是：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     Thread(object :Runnable {
    5.         override fun run() {
    6.             println("Thread if running")
    7.         }
    8.     }).start()
    9. }

    上面代码的形式类似，不过写法有些许差异，这是因为Kotlin舍弃了new关键字，因此创建匿名类就改用了object关键字。而符合Java函数式API使用条件，就可以对代码进行简化：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     Thread(Runnable {
    5.         println("Thread if running")
    6.     }).start()
    7. }

    上面的代码，Kotlin会明白Runnable后面的Lambda表达式就是要在run方法中实现的内容，同时如果Java方法的参数列表有且仅有一个Java单抽象方法接口函数，便可以对接口名进行省略：

    1. package com.example.helloworld
    2.  
    3. fun main() {
    4.     Thread{ println("Thread if running") }.start()
    5. }

    这样的话，Android中常用的点击事件接口OnClickListener，原始形式为：

    1. button.setOnClickListener(new View.OnClickListener() {
    2.     @Override
    3.     public void onClick(View v) {
    4.         
    5.     }
    6. });

    就可以简化为：

    button.setOnClickListener{ };

    空指针检查

    可空类型检查

    先看一段之前的代码：

    1. fun doStudy(study: Study) {
    2.     study.readBook()
    3.     study.doHomework()
    4. }

    上面的代码并没有进行判空处理。

    实际开发中，Java代码的大部分的方法都需要首先进行判空处理才可以保证后续的处理正常进行。而这样的检查会导致代码编写较为繁琐。而Kotlin利用编译时判空检查几乎能够杜绝空指针异常，

    还是上面的代码，虽然形式上和Java代码并没有什么区别，但实际上是没有空指针风险的，因为Kotlin默认所有的参数和变量都不可为空，即上面传入的参数study一定不为空，因此上面的函数便可以正常调用。

    即Kotlin将空指针异常的检查提前到了编译时期，即在编译期间存在空指针异常风险，会导致编译报错，而不是将错误推迟到代码执行期间，这样能保证在程序运行期间不会出现空指针异常。

    而如果所有的参数和变量都不可为空，那么确实需要某个参数或变量为空时，就需要Kotlin提供的另外一套可为空的类型系统。

    这种类型系统就是在类名后加上一个问号，比如上面的代码中，在Study后加上问号就表示此时参数study可以为空，不过此时要做判空处理：

    1. fun doStudy(study: Study?) {
    2.     if (study != null) {
    3.         study.readBook()
    4.         study.doHomework()
    5.     }
    6. }

    判空辅助工具

    在判空处理中，如果使用if处理，就会使代码变得比较繁琐，因此Kotlin提供了一系列辅助工具。

    首先最常用的就是?.操作符，该操作符是当对象不为空时正常调用相应的方法，而当对象为空时则什么都不做：

    1. fun doStudy(study: Study?) {
    2.     study?.readBook()
    3.     study?.doHomework()
    4. }

     还有一个是?:操作符，该操作符左右两边都接收一个表达式，如果左边表达式的结果不为空就返回左边表达式的结果，否则就返回右边表达式的结果：

    1. fun getTextLength(text: String?):Int {
    2.     if (text != null) {
    3.         return text.length
    4.     } else {
    5.         return 0
    6.     }
    7. }

    如果使用辅助判空工具，就可以写成：

    fun getTextLength(text: String?) = text?.length?:0

    可以说是相当简洁了。

    再比如下面的代码：

    1. package com.example.helloworld
    2.  
    3. var content: String?="hello"
    4.  
    5. fun printUpperCase() {
    6.     val upperCase = content.toUpperCase()
    7.     println(upperCase)
    8. }
    9.  
    10. fun main() {
    11.     if (content != null) {
    12.         printUpperCase()
    13.     }
    14. }
    15.

    虽然在main函数中已经进行了判空处理，但是在printUpperCase中并不清楚外部已经进行该处理，因此还是无法编译通过。

    此时如果想要强行通过编译，可以使用非空断言工具，写法是在对象后面加上!!：

    1. fun printUpperCase() {
    2.     val upperCase = content!!.toUpperCase()
    3.     println(upperCase)
    4. }

    最后一个辅助工具是let，let既不是操作符，也不是关键字，而是一个函数，该函数提供了函数式API的编程接口，并将原始调用对象作为对象传递到Lambda表达式中，如：

    obj.let {obj2 -> func}

    上面的示例中，调用了obj对象的let函数，然后Lambda表达式中的代码就会立即执行，并且该obj对象本身还会作为参数传递到Lambda表达式中。obj2只是更换了参数名，实际上和obj是同一个对象。

    let函数和判空处理结合的操作为：

    1. fun doStudy(study: Study?) {
    2.     study?.let {
    3.         it.readBook()
    4.         it.doHomework()
    5.     }
    6. }

    这样就将let函数和判空处理结合起来了，而不用每个接口方法调用都是用?.操作符。

    同时let函数是可以处理全局变量的判空问题，而if则会由于全局变量的值虽然会被其它线程更改而报错。

    杂项

    字符串内嵌表达式

    Kotlin允许在字符串中嵌入${}这中语法结构的表达式，并在运行时使用表达式执行的结果替代该内容：

    "hello,${obj.name}. nice to meet you"

    而当表达式中仅有一个变量名时，还可将两侧的大括号省略：

    "hello,$name. nice to meet you"

    函数的参数默认值

    之前提到了次构造函数，但其实次构造函数很少用，因为Kotlin能够为函数设定参数默认值。

    1. fun printParams(num:Int, str:String = "hello") {
    2.     println("num is $num, str is $str")
    3. }

    这样在调用的时候，就可以只传入num变量，而为str赋默认的值。

    而如果调换默认值的位置：

    1. fun printParams(num:Int = 10, str:String) {
    2.     println("num is $num, str is $str")
    3. }

    此时调用时便不可只写一个参数，而要使用键值对的形式进行匹配，即：

    printParams(str = "hello")

    使用键值对的形式，便不用在意参数顺序的问题，因为是通过键值对匹配的，自然不会出现类型不匹配的问题。

    这样默认的参数值在某些场景下便能够代替次构造函数的功能。

  • 相关阅读:
    【服务器数据恢复】raidz多块硬盘离线的数据恢复案例
    哈工大李治军老师操作系统笔记【9】：内核级线程（Learning OS Concepts By Coding Them !）
    避免数据泄露风险！NineData提供SQL开发规范和用户访问量管理
    数据分享|R语言分析上海空气质量指数数据：kmean聚类、层次聚类、时间序列分析：arima模型、指数平滑法...
    python项目调优合集（长期更新）：梯度爆炸、消失
    找回消失的密钥 --- DFA分析白盒AES算法
    开发者常用的API汇总，含免费次数
    紫色调城市和奔跑人物剪影背景工会工作总结汇报PPT模板
    数据中台方案分析和发展方向
    R语言混合效应（多水平/层次/嵌套）模型及贝叶斯实现技术
  • 原文地址：https://blog.csdn.net/SAKURASANN/article/details/126802002