一杯美式深入理解 data class

RockByte
1 阅读7分钟

0.png

不是魔法，是编译器替你写代码

data class 是 Kotlin 里非常“省事”的一类类型：你只要把类声明成 data class，编译器就会按约定自动生成一批标准方法，让它更像一个合格的“数据载体”。

这篇文章把 data class 的要点拆开讲清楚：它和普通类的区别到底在哪里、编译器具体生成了什么、copy() 的一些细节坑点，以及为什么“看反编译后的 Java”反而能让你更踏实。

和普通类有什么不同

一句话：data class 更偏向“只承载数据”，普通类更偏向“承载行为/逻辑”。

普通类当然也能装数据，但如果你不自己实现 equals() / hashCode() / toString() 等方法，它默认行为往往不是你想要的（比如 equals() 是引用相等）。

data class 则把“数据对象常见的、可预期的行为”变成了编译器的默认产物。

基本要素

data class 需要满足这些条件：

  • 主构造函数至少有 1 个参数
  • 主构造函数中的参数必须都声明为 val 或 var
  • data class 不能是 abstract / open / sealed / inner

编译器生成哪些能力

当你声明一个 data class，Kotlin 编译器会自动生成（或按约定提供）这些东西：

  1. equals()：做结构相等比较。只要主构造参数对应的属性值相同，就认为两个对象相等。
  2. hashCode()：基于主构造参数属性生成哈希值。保证“相等的对象有相同哈希”，以便正确用在 HashSet / HashMap 之类集合里。
  3. toString()：可读性很强的字符串形式，例如 User(name=Alice, age=30)，日志/调试非常有用。
  4. copy()：生成复制函数，允许你在保持其它属性不变的前提下修改部分属性，是不可变数据里非常核心的工具。
  5. componentN()：为主构造参数按顺序生成 component1()、component2() 等等，让你能用解构声明把对象拆成多个变量。

普通类 vs 数据类

下面的例子把 equals()、toString()、解构、copy() 四件事一次看明白：

class NormalUser(val name: String, val age: Int)

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

fun main() {
    val normalUser1 = NormalUser("Alice", 30)
    val normalUser2 = NormalUser("Alice", 30)

    val dataUser1 = DataUser("Alice", 30)
    val dataUser2 = DataUser("Alice", 30)

    // 1. equals()
    println(normalUser1 == normalUser2) // 输出：false（内存中的不同对象）
    println(dataUser1 == dataUser2)     // 输出：true（属性值相同）

    // 2. toString()
    println(normalUser1) // 输出类似：NormalUser@1f32e575
    println(dataUser1)   // 输出：DataUser(name=Alice, age=30)

    // 3. 用 componentN() 做解构
    val (name, age) = dataUser1
    println("Name: $name, Age: $age") // 输出：Name: Alice, Age: 30
    // val (name2, age2) = normalUser1 // 编译错误，普通类没有结构

    // 4. copy()
    val dataUser3 = dataUser1.copy(age = 31)
    println(dataUser3) // 输出：DataUser(name=Alice, age=31)
    // val normalUser3 = normalUser1.copy() // 编译错误，普通类没有 copy
}

在上面的例子中，Kotlin 会自动为 User 类提供 equals()、hashCode()、toString() 和 copy()。

数据类与普通类的差异

除了自动生成的这些函数之外，data class 和普通类之间还有几个关键差异。

  1. 减少样板代码：在普通类中，你需要手动重写 equals()、hashCode()、toString() 以及其他工具方法。而对于 data class，Kotlin 会自动为你生成这些内容。
  2. 主构造函数要求：data class 要求至少有一个属性声明在主构造函数中，而普通类则没有这个要求。
  3. 使用场景：data class 通常用于承载来自 I/O 过程的数据，例如数据库和网络中的只读领域数据（当然你也可以使用可变属性）；而普通类则可以用于任何行为或逻辑。

总之，data class 用于那些只包含数据的对象，Kotlin 编译器会自动生成诸如 equals()、hashCode()、toString() 和 copy() 之类的工具方法。

而普通类更灵活，但默认不会提供这些方法，因此它更适合承载行为和复杂逻辑的对象。

进阶一：继承

有一个 KEEP 提案在探索：让 data class 具备继承的特性。

提案思路是，在尽量保留 equals() / hashCode() / copy() 等关键特性的同时，允许它参与继承层级。

但这件事会带来新的复杂度，例如：

  • 继承后如何处理构造函数的参数;
  • 如何处理“继承来的属性”和 data class 主构造参数之间的边界;
  • 怎样覆盖 componentN() 等生成函数

目前，可以关注这个提案，不过在语言方面还没有这个特性。

进阶二：copy() 的可见性

当你的 data class 有私有（private）主构造函数时，自动生成的 copy() 可能会暴露出“你不想公开”的构造能力，从而引发一些意外。

下面是一个会在 Kotlin 2.0.20 触发 warning 的例子：

// 在 2.0.20 会触发 warning
data class PositiveInteger private constructor(val number: Int) {
    companion object {
        fun create(number: Int): PositiveInteger? =
            if (number > 0) PositiveInteger(number) else null
    }
}

fun main() {
    val positiveNumber = PositiveInteger.create(42) ?: return
    // 在 2.0.20 会触发 warning
    val negativeNumber = positiveNumber.copy(number = -1)
    // Warning: data class 生成的 'copy()' 暴露了非 public 的主构造函数
    // 未来版本里，生成的 'copy()' 会改变其可见性
}

为了平滑迁移，Kotlin 提供了这些手段（按“作用域”从小到大）：

  • @ConsistentCopyVisibility：让你提前 opt-in 到未来的新行为（copy() 的默认可见性会与构造函数对齐）。
  • @ExposedCopyVisibility：让你在声明处 opt-out 新行为并抑制 warning。不过即便加了这个注解，当你调用 copy() 时编译器依然可能发出 warning。
  • 编译器选项 -Xconsistent-data-class-copy-visibility：在 Kotlin 2.0.20 中可以对整个 module 启用新行为，效果相当于给该 module 中的所有 data class 都加上 @ConsistentCopyVisibility。

更细的迁移节奏与背景可以参考对应的 YouTrack 讨论。

进阶三：看懂反编译

很多从 Java 转 Kotlin 的同学，会觉得 Kotlin “现代又神奇”，好像很多事都被语言自动搞定了。

最直接的去幻觉方式就是：看一眼反编译后的 Java Bytecode。

我经常这么干，这个是学习 Kotlin 的一个非常棒的方法！

先从一个极简 data class 开始：

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

反编译后，你大致会看到这样的 Java 代码（节选）：

import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

// data class 会变成一个 final Java class。
public final class User {

    @NotNull
    private final String name;
    private final int age;

    // 1. 标准构造函数与 getters。
    public User(@NotNull String name, int age) {
        Intrinsics.checkNotNullParameter(name, "name");
        this.name = name;
        this.age = age;
    }

    @NotNull
    public final String getName() {
        return this.name;
    }

    public final int getAge() {
        return this.age;
    }

    // 2. 用于解构的 componentN() 方法。
    @NotNull
    public final String component1() {
        return this.name;
    }

    public final int component2() {
        return this.age;
    }

    // 3. 用于不可变更新的 copy() 方法。
    @NotNull
    public final User copy(@NotNull String name, int age) {
        Intrinsics.checkNotNullParameter(name, "name");
        return new User(name, age);
    }

    // copy 的合成重载，用来处理默认参数逻辑（synthetic）。
    public static /* synthetic */ User copy$default(User self, String name, int age, int mask, Object obj) {
        if ((mask & 1) != 0) {
            name = self.name;
        }

        if ((mask & 2) != 0) {
            age = self.age;
        }

        return self.copy(name, age);
    }

    // 4. 可读且好用的 toString()。
    @NotNull
    public String toString() {
        return "User(name=" + this.name + ", age=" + this.age + ")";
    }

    // 5. 基于内容的 hashCode()。
    public int hashCode() {
        return this.name.hashCode() * 31 + this.age;
    }

    // 6. 结构相等的 equals()。
    public boolean equals(@Nullable Object other) {
        if (this == other) {
            return true;
        }

        if (!(other instanceof User)) {
            return false;
        }

        User otherUser = (User) other;
        if (!Intrinsics.areEqual(this.name, otherUser.name)) {
            return false;
        }

        if (this.age != otherUser.age) {
            return false;
        }

        return true;
    }
}

反编译后的代码表明，data 关键字本质上是向编译器发出的指令，用于自动生成以下（大量）方法：

  1. 标准构造函数与 Getters：编译器会创建一个公共构造函数，其参数与主构造函数完全一致。对于每个 val 属性，会生成一个 final 字段和一个公共的取值方法。
  2. componentN() 方法：针对主构造函数中的每个属性，都会生成对应的 componentN() 方法（例如，name 对应 component1()，age 对应 component2()）。这些运算符函数是 Kotlin 中解构声明的核心实现，让你可以写出 val (name, age) = user 这样的代码。
  3. copy() 方法：生成一个 copy() 方法，允许你创建该类的新实例，同时可选择性地修改部分属性。这是操作不可变数据结构的基础能力——它提供了一种简洁的方式，从旧状态生成新状态。编译器还会生成一个合成的 copy$default 方法，用于处理默认参数逻辑（即：若未提供新值，则沿用原有值）。
  4. toString() 方法：生成一个可读性强的 toString() 实现。它不会返回默认的「类名@内存地址」格式，而是输出清晰的字符串（如 User(name=Alice, age=30)），这对日志打印和调试工作至关重要。
  5. hashCode() 方法：基于主构造函数属性的内容生成一个规范的 hashCode() 方法。这一点尤为重要：它确保两个拥有相同 name 和 age 的 User 实例会生成相同的哈希值——这是对象用于基于哈希的集合（如 HashSet）或作为 HashMap 键值时必须遵守的约定。
  6. equals() 方法：生成一个基于结构比较的 equals() 方法。该方法会先检查另一个对象是否为同一类型，再逐一比较主构造函数中每个属性的相等性。这意味着 User("Alice", 30) == User("Alice", 30) 会正确返回 true，这也是数据承载类应有的直观行为；而普通类会执行引用相等性检查，最终返回 false。

是不是感觉其中部分内容在之前的问题里已经讲过了？

英文反编译结果把事情说得很直白：data 关键字本质上是一个指令，告诉编译器在编译期生成一整套“数据对象应有的行为”。data class 并不神秘，只是编译器替你做了大量机械但容易出错的重复工作。

结论

data class 的价值可以归结为两点：

  • 让“数据对象”默认具备合理且一致的行为（equals() / hashCode() / toString() / copy() / componentN()）
  • 省掉大量重复且容易写错的样板代码，让你把注意力放在业务语义而不是模板上

对了，如果你想知道使用 data class 有哪些陷阱，看这里！

avatar
文章
阅读
粉丝