17370845950

Java 作为编程语言的佼佼者，其开发者在学习 Kotlin 时常会犯一些相似的错误。 这并非真正的错误，而是指开发者习惯性地沿用 Java 的编程思维，而非充分利用 Kotlin 的特性所导致的代码风格问题。

本文旨在帮助您识别这些常见的代码风格问题，并学习如何用更符合 Kotlin 风格的方式进行改进。

本系列的第一部分将涵盖以下主题：

• 数据类的运用
• 空安全性的运用
• 默认不变性

数据类的运用

虽然越来越多的 Java 开发者开始熟悉记录类，但这个主题仍然值得关注，因为 Java 记录类和 Kotlin 数据类之间存在一些差异。

Java 风格：

public class Person {
  private String name;
  private int age;

  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  // getters, setters, ...
}

或者使用记录类：

public record Person(
    String name,
    int age
) {}

Kotlin 风格：

data class Person(val name: String, var age: Int)

Java 记录类和 Kotlin 数据类之间存在一些关键差异：

• 两者都是不可变的数据载体。
• Java 中的字段隐式为 final，创建后不可修改；Kotlin 中，您可以使用 val 或 var 来选择字段的可变性。
• Java 记录类隐式为 final 并密封，不可扩展；Kotlin 数据类则可以扩展。
• Kotlin 可以重写 equals、hashCode 和 toString 方法，Java 则不行。
• Kotlin 提供开箱即用的复制方法，Java 没有。

一些示例：

在 Java 中复制对象：

Person p2 = new Person(p1.getName(), p1.getAge());

Kotlin：

val p2 = p1.copy(age = 42)

Java 中的解构声明：

String name = p1.getName();
int age = p1.getAge();

Kotlin：

val (name, age) = p1
println(name) // "john"
println(age) // 42

参考

• Kotlin 数据类
• Baeldung：Kotlin 数据类

---

空安全性的运用

Kotlin 的空安全性是其最强大的功能之一，它能有效避免与 null 相关的运行时错误。

1. 可空类型

Kotlin 中，可空类型是显式声明的。这意味着您可以声明一个可能包含 null 值的变量，但必须在声明中使用 ? 运算符。

不可为空类型（默认行为）

默认情况下，Kotlin 类型是不可为空的，不能保存 null 值。

val name: String = "john" // 不可为空
name = null // 编译错误!

可空类型

要声明可空类型，需使用 ? 运算符：

val name: String? = null // 可空

2. 安全调用

安全调用运算符 ?. 允许您安全地调用方法或访问属性，避免 NullPointerException。

示例

val name: String? = null
println(name?.length) // 打印 null，而非抛出异常

?. 运算符会检查对象是否为 null，如果是，则返回 null；否则继续调用方法或访问属性。

3. Elvis 运算符 (?:)

Elvis 运算符 ?: 提供了简写形式，如果左侧表达式为 null，则返回默认值。

val name: String? = null
val length = name?.length ?: 0 // name 为 null 时，默认值为 0
println(length) // 0

4. !! 运算符（非空断言）

!! 运算符告诉编译器该值不为空。如果值为 null，则会抛出 NullPointerException。

val name: String? = null
println(name!!) // 抛出 NullPointerException

提示： 建议尽量避免使用 !! 运算符。

5. 函数参数的可为空性

定义函数时，可以指定参数是否可为空。

fun greet(name: String?) {
    println("Hello, ${name ?: "guest"}")
}
greet(null) // Hello, guest
greet("Alice") // Hello, Alice

6. 安全转换（as? 运算符）

安全强制转换运算符 as? 在转换失败时返回 null。

val obj: Any = "Kotlin"
val str: String? = obj as? String
println(str) // 打印 "Kotlin"

val num: Int? = obj as? Int
println(num) // 打印 null

7. lambda 表达式中的空安全性

在 lambda 表达式中同样可以使用空安全特性：

val list: List = listOf("Kotlin", null, "Java")
val lengths = list.map { it?.length ?: 0 }
println(lengths) // 打印 [6, 0, 4]

8. 使用 let 函数

let 函数允许您在非空对象上执行代码块，通常用于安全地处理可空对象。

val name: String? = null

val result = name?.let {
    println("name is not null: $it")
    it.length // name 为 null 时，此行不会执行
} ?: "default value"

println(result) // 打印 "default value"

9. 最佳实践

• 避免使用 !! 运算符
• 使用安全调用和 Elvis 运算符安全处理可空类型
• 谨慎使用可空类型

参考：

• Kotlin 空安全

---

默认不变性

Kotlin 鼓励函数式编程风格。不变性在避免错误，尤其是在多线程应用中，至关重要。

Kotlin 更倾向于使用不可变对象。这使得代码更简洁、更易预测。

1. 默认不可变变量 (val)

Kotlin 中，使用 val 关键字声明的变量默认是不可变的。这与 Java 中的 final 变量类似，但有一些关键区别：

• Kotlin 的 val 变量是只读的，初始化后无法更改其值。
• 但如果该值是一个对象，则该对象的属性仍然可以更改，除非这些属性本身被声明为 val。

示例：

val name = "Kotlin"
// name = "Java" // 编译错误!

与 Java 的区别：Java 中，final 关键字只保证变量的引用不可变，但对象本身可能可变。Kotlin 的 val 则保证了变量及其引用的对象不可变。

可变变量示例：
使用 var 关键字声明可变变量：

var age = 42
age = 43 // 没有编译错误

提示：
尽可能使用 val 而不是 var。

2. 不可变集合

Kotlin 也鼓励使用不可变集合。不可变集合创建后无法修改。

val numbers = listOf(1, 2, 3)
numbers.add(4) // 编译错误!

如果需要修改集合，可以使用 mutableListOf() 等可变集合类型。

val mutableNumbers = mutableListOf(1, 2, 3)
mutableNumbers.add(4) // 允许

与 Java 的区别：Java 集合（如 ArrayList）默认是可变的。

3. 不可变数据类

Kotlin 数据类默认是不可变的。属性通常声明为 val。

data class Person(val name: String, val age: Int)

val person = Person("Alice", 42)
person.name = "Bob" // 编译错误!

4. 密封类中的不变性

Kotlin 密封类也可以是不可变的，常用于表示受限的类层次结构，例如状态或响应。

sealed class Response
data class Success(val data: String) : Response()
data class Error(val message: String) : Response()

val response: Response = Success("Data loaded successfully")
response = Error("Something is wrong") // 编译错误!