Kotlin重点理解安全性_kotlinas?

一 Kotlin安全性

Kotlin 在设计时采用了一系列策略，旨在尽可能地减少空指针异常（NullPointerException）的出现。空指针异常是许多编程语言中常见的错误之一，Kotlin 通过以下几种方式来避免它：

1. 可空类型（Nullable Types）：Kotlin引入了可空类型的概念，允许变量具有可以存储空值的能力。在 Kotlin 中，如果一个变量可能为 null，必须显式地声明为可空类型。例如，使用 String? 表示一个可能为null的字符串类型。这样做可以在编译时就捕捉到潜在的空指针异常，因为 Kotlin 不允许直接对可空类型进行操作，除非先进行非空判断或者安全调用。
2. 安全调用运算符（Safe Call Operator）：在 Kotlin 中，可以使用 ?. 运算符来调用可空对象的方法或访问其属性。如果对象为 null，则整个表达式将返回 null 而不会导致空指针异常。例如，obj?.someMethod() 将返回 null，如果 obj 是 null，否则调用 someMethod() 方法。
3. Elvis 运算符（Elvis Operator）：Elvis 运算符 ?: 可以用于提供默认值，如果表达式的值为 null，则可以返回提供的默认值。例如，val length = str?.length ?: 0 表示如果 str 是 null，length 将赋值为 0。
4. 非空断言运算符（Non-null Assertion Operator）：有时候我们可以确定某个可空类型的变量在某个地方不会为 null，这时可以使用非空断言运算符 !! 来显式地告诉编译器该变量不会为 null。但是需要小心使用它，如果变量为 null，将会触发空指针异常。
5. 安全类型转换（Safe Cast）：使用 as? 运算符进行安全类型转换，如果转换失败，则返回 null。这样可以避免在类型转换时出现空指针异常。
6. 延迟初始化：在 Kotlin 中，类的属性可以使用 lateinit 延迟初始化，这使得在声明属性时不需要立即初始化，而可以在稍后进行初始化。但是要小心使用延迟初始化，必须确保在使用该属性之前已经初始化，否则会抛出异常。

1.1 可空类型

在 Kotlin 中，可空类型（Nullable Types）允许变量具有可以存储 null 值的能力。通常，变量的类型不能为 null，如果试图将 null 赋值给非空类型的变量，编译器会报错。但是，有时候我们需要表示一个变量可能为 null 的情况，这就是可空类型的用途。
在 Kotlin 中，声明可空类型的变量时，在类型名称后面添加一个问号 ? 来表示该变量可以为 null。例如，String? 表示一个可能为 null 的字符串类型，Int? 表示一个可能为 null 的整数类型。
以下是一些可空类型的示例：

fun main() {
    var name: String? = "John" // 可以为 null 的字符串
    var age: Int? = null // 可以为 null 的整数

    val nullableList: List<Int>? = listOf(1, 2, 3) // 可以为 null 的整数列表

    // 当然，我们也可以使用非空类型的列表
    val nonNullableList: List<Int> = listOf(1, 2, 3)
}
1
2
3
4
5
6
7
8
9

在使用可空类型时，需要特别注意处理可能为 null 的情况，以避免空指针异常。Kotlin 提供了多种方式来处理可空类型的变量：

1. 安全调用操作符 ?.：允许在不确定变量是否为 null 的情况下，调用其方法或访问其属性。如果变量为 null，则整个表达式会返回 null。

val length = name?.length // 如果 name 不为 null，则返回 name 的长度，否则返回 null
1

1. Elvis 操作符 ?:：用于在表达式为 null 时提供默认值。

val nonNullName = name ?: "Unknown" // 如果 name 不为 null，则使用 name 的值，否则使用 "Unknown"
1

1. 安全类型转换 as?：用于安全地进行类型转换，如果转换失败，则返回 null。

val intValue: Int? = stringValue as? Int // 如果 stringValue 可以转换为 Int，则返回 Int 值，否则返回 null
1

通过使用可空类型和相应的操作符，我们可以在编译时处理潜在的 null 值，避免空指针异常，并使得代码更加健壮和安全。

val str: String? = null
val length = str.length // 编译错误：str 可能为 null
1
2

let 函数可以用于在非空的情况下执行某些操作，例如：

val str: String? = null
str?.let {
    // str 不为 null 时执行
    println(it.length)
}
1
2
3
4
5

optional 函数可以用于在可空类型的变量为 null 时执行某些操作，例如：

val str: String? = null
str.optional {
    // str 为 null 时执行
    println("str is null")
}
1
2
3
4
5

1.2 安全调用运算符

在 Kotlin 中，安全调用运算符（Safe Call Operator）是一种用于处理可空类型的特殊运算符。它允许你在不确定一个可空类型变量是否为 null 的情况下，安全地调用它的方法或访问它的属性。如果变量为 null，那么整个表达式会返回 null，而不会导致空指针异常。
安全调用运算符的语法是 ?.，它用于在可空类型变量后面调用其方法或访问其属性。以下是使用安全调用运算符的示例：

fun printLength(name: String?) {
    val length = name?.length
    println("Length of name: $length")
}

fun main() {
    printLength("John") // 输出: Length of name: 4
    printLength(null) // 输出: Length of name: null
}
1
2
3
4
5
6
7
8
9

在上面的示例中，我们定义了一个名为 printLength 的函数，它接受一个可空类型的字符串 name 作为参数。在函数中，我们使用安全调用运算符 name?.length 来获取 name 字符串的长度，如果 name 是 null，则整个表达式会返回 null，否则返回字符串的长度。这样，在处理可空类型时，就不需要手动进行 null 检查，可以避免空指针异常。
安全调用运算符在处理链式调用时尤为有用。例如，如果我们有一个可空类型的对象 person，它有一个可空类型的属性 address，并且 address 有一个可空类型的属性 city，我们可以通过链式使用安全调用运算符来避免多层嵌套的 null 检查：

val city = person?.address?.city
1

上面的代码会在 person、address 或 city 中任何一个为 null 时返回 null，而不会抛出空指针异常。
通过使用安全调用运算符，我们可以更加简洁和安全地处理可空类型的变量，减少了大量的 null 检查代码，提高了代码的可读性和健壮性。

1.3 Elvis 运算符

在 Kotlin 中，Elvis 运算符 ?: 是一种用于处理可空类型的特殊运算符。它提供了一种简洁的方式来为可能为 null 的表达式提供一个默认值。如果表达式的值为 null，那么 Elvis 运算符会返回指定的默认值，否则返回表达式的值。
Elvis 运算符的语法是 expression ?: defaultValue，其中 expression 是一个可能为 null 的表达式，defaultValue 是一个默认值，用于在 expression 为 null 时返回。
以下是使用 Elvis 运算符的示例：

fun printLength(name: String?) {
    val length = name?.length ?: -1
    println("Length of name: $length")
}

fun main() {
    printLength("John") // 输出: Length of name: 4
    printLength(null) // 输出: Length of name: -1
}
1
2
3
4
5
6
7
8
9

在上面的示例中，我们定义了一个名为 printLength 的函数，它接受一个可空类型的字符串 name 作为参数。在函数中，我们使用 Elvis 运算符 name?.length ?: -1 来获取 name 字符串的长度，如果 name 是 null，则整个表达式会返回 -1，否则返回字符串的长度。这样，我们可以指定一个默认值 -1，以避免 name 为 null 时导致的空指针异常。
Elvis 运算符还可以用于链式调用中的多个可空类型变量：

val city = person?.address?.city ?: "Unknown"
1

在上面的代码中，如果 person、address 或 city 中任何一个为 null，都会返回 “Unknown” 作为默认值。
通过使用 Elvis 运算符，我们可以更加简洁地处理可空类型的变量，并在需要时为其提供默认值，使得代码更加健壮和安全。

1.4 非空断言运算符

在 Kotlin 中，非空断言运算符 !! 是一种用于处理可空类型的特殊运算符。它用于显式地告诉编译器一个可空类型的变量不会为 null，从而允许在变量为 null 的情况下进行非空操作。
非空断言运算符的语法是 expression!!，其中 expression 是一个可空类型的变量。如果 expression 不为 null，那么 expression!! 会返回它的值；但如果 expression 为 null，那么在运行时会抛出 NullPointerException。
需要注意的是，非空断言运算符 !! 是一种危险的操作。如果使用不当，会导致空指针异常，因此应该谨慎使用。通常情况下，最好避免使用 !!，而是使用安全调用运算符 ?. 或 Elvis 运算符 ?: 来处理可空类型的变量。
以下是使用非空断言运算符的示例：

fun printLength(name: String?) {
    val length = name!!.length
    println("Length of name: $length")
}

fun main() {
    printLength("John") // 输出: Length of name: 4
    printLength(null) // 抛出 NullPointerException
}
1
2
3
4
5
6
7
8
9

在上面的示例中，我们定义了一个名为 printLength 的函数，它接受一个可空类型的字符串 name 作为参数。在函数中，我们使用非空断言运算符 name!!.length 来获取 name 字符串的长度。如果 name 是 null，则在运行时会抛出 NullPointerException。
尽管非空断言运算符 !! 可以在某些情况下方便地处理可空类型的变量，但它应该谨慎使用，并且只在你能确保变量不会为 null 的情况下使用。通常情况下，推荐使用更安全的操作符来处理可空类型，以避免潜在的空指针异常。

1.5 安全类型转换

在 Kotlin 中，安全类型转换（Safe Cast）是一种用于处理类型转换的特殊操作符。它允许你安全地将一个对象转换为指定类型，如果转换失败，则返回 null，而不会抛出 ClassCastException 异常。
安全类型转换的语法是 as?，它用于将一个对象转换为指定类型，并返回转换后的对象。如果转换失败，则整个表达式会返回 null。
以下是使用安全类型转换的示例：

fun printLength(name: Any) {
    val length = (name as? String)?.length
    println("Length of name: $length")
}

fun main() {
    printLength("John") // 输出: Length of name: 4
    printLength(42) // 输出: Length of name: null
}
1
2
3
4
5
6
7
8
9

在上面的示例中，我们定义了一个名为 printLength 的函数，它接受一个 Any 类型的参数 name。在函数中，我们首先使用 as? 运算符将 name 对象安全地转换为 String 类型。如果 name 是 String 类型，则转换成功，我们可以获取它的长度并打印；如果 name 不是 String 类型，则转换失败，整个表达式会返回 null。
在 main 函数中，我们分别调用了 printLength(“John”) 和 printLength(42)。第一个调用中，name 是一个字符串，转换成功，打印字符串的长度。第二个调用中，name 是一个整数，转换失败，返回 null。
安全类型转换可以帮助我们处理不确定对象类型的情况，而不会出现 ClassCastException 异常。它是一种安全而方便的方式来进行类型转换，特别在处理多态类型的对象时很有用。

1.6 延迟初始化

在 Kotlin 中，延迟初始化（Late Initialization）是一种允许在声明属性时不立即初始化的特性。在某些情况下，我们希望在稍后的时间点才对属性进行初始化，例如在构造函数执行之后或在对象创建之后。
为了实现延迟初始化，我们需要在属性声明中使用 lateinit 关键字，并将属性的类型设置为非空类型（不可为 null）。这样，编译器会知道该属性会在稍后被初始化，而不会在初始化阶段要求立即赋值。
以下是一个简单的示例，演示了如何在 Kotlin 中使用延迟初始化：

class Person {
    lateinit var name: String
    lateinit var age: Int

    fun init(name: String, age: Int) {
        this.name = name
        this.age = age
    }
}

fun main() {
    val person = Person()
    person.init("Alice", 30)

    println("Name: ${person.name}")
    println("Age: ${person.age}")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在上面的示例中，我们定义了一个 Person 类，其中的 name 和 age 属性使用了延迟初始化。我们在类的 init 方法中进行属性的初始化。因为属性使用了 lateinit 关键字，所以在创建 Person 对象时，并不需要立即为 name 和 age 赋值。相反，我们可以在稍后的时间点通过调用 init 方法来为它们赋值。
需要注意的是，使用 lateinit 的属性必须是非空类型，并且必须在对象的生命周期内进行初始化，否则会抛出 UninitializedPropertyAccessException 异常。因此，使用延迟初始化时要确保在使用属性之前已经进行了初始化。
延迟初始化非常有用，可以在某些情况下优化对象的创建和初始化过程，避免不必要的资源消耗，并提高代码的性能。但是要小心使用它，确保在适当的时间点对属性进行初始化。