Android Kotlin（一）简洁的编程语言-关键字

在 2019 年 Google I/O 大会上宣布今后将优先采用 Kotlin 进行 Android 开发。Kotlin 是一种富有表现力且简洁的编程语言，不仅可以减少常见代码错误，还可以轻松集成到现有应用中。

为什么要优先使用 Kotlin 进行 Android 开发？

根据来自开发者、客户顾问委员会 (CAB)、Google Developers 专家 (GDE) 的反馈，以及我们通过开发者调研获得的反馈。许多开发者已喜欢上使用 Kotlin，且提供更多 Kotlin 支持的呼声很高。下面介绍了开发者喜欢用 Kotlin 编写代码的原因：

• 富有表现力且简洁：您可以使用更少的代码实现更多的功能。表达自己的想法，少编写样板代码。在使用 Kotlin 的专业开发者中，有 67% 的人反映其工作效率有所提高。
• 更安全的代码：Kotlin 有许多语言功能，可帮助您避免 null 指针异常等常见编程错误。包含 Kotlin 代码的 Android 应用发生崩溃的可能性降低了 20%。
• 可互操作：您可以在 Kotlin 代码中调用 Java 代码，或者在 Java 代码中调用 Kotlin 代码。Kotlin 可完全与 Java 编程语言互操作，因此您可以根据需要在项目中添加任意数量的 Kotlin 代码。
• 结构化并发：Kotlin 协程让异步代码像阻塞代码一样易于使用。协程可大幅简化后台任务管理，例如网络调用、本地数据访问等任务的管理。

---

静态类型的语言：Kotlin

在Kotlin中是没有static关键字的，也就是意味着没有了静态方法和静态成员。而且Kotlin中的类、函数和变量在默认是 final 的，即它们不能从任何其他类继承。 因此，为了使其可从其他类继承，我们使用带有类、函数和变量名的 open 关键字。

变量声明

Kotlin 使用两个不同的关键字（即 val 和 var）来声明变量。

• val 用于值从不更改的变量。使用 val 声明的变量无法重新赋值。
• var 用于值可以更改的变量。

Const 关键字

• const只能修饰val，不能修饰var类型变量；
• const 只在top-level级别和object中声明。

  const val constVariable = "const_variable"
  object obj{
      const val constVariable = "const_variable"
  }
  class ConstKotlin {
      companion object{
          const val constVariable = "const_variable"
      }
  }

  （1）val 修饰的属性相当于java中private final static修饰的常量；
  （2）const val 修饰的属性相当于java中的public final static修饰的常量；
  （3）出于性能考虑，使用const val方式可以避免频繁函数调用。

Object关键字

object关键字来声明一个类时，可以替换class关键字。它声明的对象是一种单例调用。 

object RepositoryManager{
    fun method(){}
}
//调用
fun main(args: Array<String>) {
    RepositoryManager.method()
}

• object declaration：当第一次访问它时才初始化，是一种懒加载单例模式。
• Companion object：当它外部类被加载后才初始化，类似Java中的静态代码块。

类型推断

Kotlin 编译器可根据所赋值的类型来推断其类型。利用 Kotlin 的类型推断，既能确保代码简洁，又能确保类型安全。

val languageName = "Kotlin"
val upperCaseName = languageName.toUpperCase()
// Fails to compile
languageName.inc()

示例，为 languageName 赋予初始值后，languageName 推断为 String，因此无法对其调用任何不属于 String 类的函数。

Null 安全

在其他语言中，声明的引用类型变量默认null值。Kotlin 变量不能持有 null 值。要使变量持有 null 值，它必须是可为 null 类型。可以在变量类型后面加上 ? 后缀，将变量指定为可为 null。

// Fails to compile
val languageName: String = null

val languageName: String? = null

条件语句

Kotlin 提供了几种实现条件逻辑的机制，其中最常见的是 if-else 语句。如果每个分支都是输出一个 String。为了避免这种重复，Kotlin 提供了条件表达式：

val answerString: String = if (count == 42) {
    "I have the answer."
} else if (count > 35) {
    "The answer is close."
} else {
    "The answer eludes me."
}
println(answerString)

注意：Kotlin 不包含传统的三元运算符。也可以使用 when 表达式，如以下示例所示：

val answerString = when {
    count == 42 -> "I have the answer."
    count > 35 -> "The answer is close."
    else -> "The answer eludes me."
}
println(answerString)

Fun关键字

在Kotlin 中的所有函数在默认也都是 final的，即方法不允许被重写。需加open关键字。

使用fun声明函数，示例如下：

fun generateAnswerString(countThreshold: Int): String {
    val answerString = if (count > countThreshold) {
        "I have the answer."
    } else {
        "The answer eludes me."
    }
    return answerString
}
val answerString = generateAnswerString(42)

简化函数：

fun generateAnswerString(countThreshold: Int): String = if (count > countThreshold) {
        "I have the answer"
    } else {
        "The answer eludes me"
    }

高阶函数：一个函数可以将另一个函数当作参数。

fun stringMapper(str: String, mapper: (String) -> Int): Int {
    // Invoke function
    return mapper(str)
}

repeat关键字 & delay关键字

repeat函数可以用来重复执行每个操作多次。它接受一个int类型参数来指定重复的次数。示例：

/重复5次
repeat(5) {
    //间隔1000毫秒
    delay(1000L)
    println（”hello world“）;
}

类&属性

默认类和属性都是final public修饰的。即不可继承和重写，需要加open关键字修饰才可以。

例如，汽车需要轮子来驱动，添加 Wheel 对象的列表作为 Car 的属性，如下示例：

class Car {
    val wheels = listOf<Wheel>()
}
//或者
class Car(val wheels: List<Wheel>)

注意，wheels 默认是一个 public val，可以从 Car 类外部访问 wheels。

val car = Car() // construct a Car
val wheels = car.wheels // retrieve the wheels value from the Car

如果希望公开属性的 getter 而限制访问其 setter，则可以将该 setter 指定为 private：

class Car(val wheels: List<Wheel>) {
    private val doorLock: DoorLock = ...
    var gallonsOfFuelInTank: Int = 15
        private set
    fun unlockDoor(key: Key): Boolean {
        // Return true if key is valid for door lock, false otherwise
    }
}

data 关键字

在kotlin中数据类通过data关键字来修饰。使用data修饰数据类的条件：

• 数据类不能用abstract、open、sealed修饰，也不能定义成内部类；
• 数据类可以实现接口也可以继承其他类；
• 主构造器必须至少有一个用var/val声明的参数；
• 如果想让JVM为数据类生成一个无参构造，参数必须都有默认值。示例代码如下：

data class Result(var code:Int=0,val msg:String=""){}

 sealed 关键字 

用于声明一个"密封类"（sealed class），是一种特殊的抽象类，用于限制继承它的子类，并且在处理密封类实例时提供编译时安全性和警告。示例如下：

sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
}
fun handleResult(result: Result) {
    when (result) {
        is Result.Success -> {
            println("Success: ${result.data}")
        }
        is Result.Error -> {
            println("Error: ${result.message}")
        }
    }
}

上例中，密封类Result有两个子类：Success和Error。handleResult函数接受一个Result参数，并使用when表达式来处理不同的结果类型。

使用密封类时，编译器会提示我们是否已经覆盖了所有可能的情况。如果我们忘记处理某个子类，编译器会给出警告。这样可以帮助我们编写更可靠的代码。

---

互操作性

        Kotlin与 Java 之间流畅的互操作性。由于 Kotlin 代码可编译为 JVM 字节码，因此 Kotlin 代码可直接调用 Java 代码，反之亦然。这意味着，您可以直接从 Kotlin 利用现有的 Java 库。此外，绝大多数 Android API 都是用 Java 编写的，因此可以直接从 Kotlin 调用它们。

下一篇，继续介绍 Kotlin 语言在 Android 实战开发过程中最有用的一些方面。