【Kotlin】Kotlin学习八-数据类和密封类

学而不思则罔，思而不学则殆

---

数据类

我们经常创建一些只保存数据的类。 在这些类中，一些标准函数往往是从数据机械推导而来的。在 Kotlin 中，这叫做 数据类 并标记为 data ：

data class User(val name: String, var age: Int)
data class Student(val user: User, val studentId: Int)

查看字节码：

86183@DESKTOP-MKB5ERF MINGW64 /d/Study/KotlinWord/MyKotlinWorld/out/production/MyKotlinWorld/com/algorithm
$ javap User.class
Compiled from "TestOne.kt"
public final class com.algorithm.User {
  public final java.lang.String getName();
  public final int getAge();
  public final void setAge(int);
  public com.algorithm.User(java.lang.String, int);
  public final java.lang.String component1();
  public final int component2();
  public final com.algorithm.User copy(java.lang.String, int);
  public static com.algorithm.User copy$default(com.algorithm.User, java.lang.String, int, int, java.lang.Object);
  public java.lang.String toString();
  public int hashCode();
  public boolean equals(java.lang.Object);
}

由于name是val,所以只有getName方法，而age是var,所以有get和set方法。其他方法都是默认的，可以了解一下。
编译器自动从主构造函数中声明的所有属性导出以下成员：

• equals() / hashCode() 对；
• toString() 格式是 “User(name=John, age=42)” ；
• componentN() 函数 按声明顺序对应于所有属性；
• copy() 函数（见下文）。

为了确保生成的代码的一致性以及有意义的行为，数据类必须满足以下要求：

• 主构造函数需要至少有一个参数；
• 主构造函数的所有参数需要标记为 val 或 var ；
• 数据类不能是抽象、开放、密封或者内部的；
• （在1.1之前）数据类只能实现接口。

在 JVM 中，如果生成的类需要含有一个无参的构造函数，则所有的属性必须指定默认值。

data class User(val name: String = "zy", val age: Int = 18)

在类体中声明的属性

请注意，对于那些自动生成的函数，编译器只使用在主构造函数内部定义的属性。如需在生成的实现中排除一个属性，请将其声
明在类体中：

data class Person(val name: String) {
    var age: Int = 0
}

在 toString() 、 equals() 、 hashCode() 以及 copy() 的实现中只会用到 name 属性，并且只有一个 component 函数 component1() 。虽然两个 Person 对象可以有不同的年龄，但它们会视为相等。

测试：

fun main() {
    val user1 = Person("zy")
    user1.age = 18
    val user2 = Person("zy")
    user2.age = 18
    println(user1)
    println(user2)
    println(user1 == user2)
}

结果：

Person(name=zy)
Person(name=zy)
true

复制

在很多情况下，我们需要复制一个对象改变它的一些属性，但其余部分保持不变。 copy()函数就是为此而生成。

    data class Person(val name: String, var age: Int)
    val jack = Person(name = "Jack", age = 1)
    val olderJack1 = jack.copy(age = 2)
    val olderJack2 = jack.copy(name = "zy")
    val olderJack3 = jack.copy()

数据类与解构声明

为数据类生成的 Component 函数 使它们可在解构声明中使用：

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

    val jack = Person(name = "Jack", age = 18)
    val (name, age) = jack
    println("$name, $age years of age") // 输出 "Jack, 18 years of age"
}

输出：

Jack, 18 years of age

标准数据类

标准库提供了 Pair 与 Triple 。尽管在很多情况下具名数据类是更好的设计选择， 因为它们通过为属性提供有意义的名称使代码更具可读性。

测试Pair（二元）

fun main() {
    val pair1 = Pair(1, 2)
    println(pair1)
    val pair2 = 1 to 2
    println(pair2)

    val pair3 = 1 to 2 to 3
    println(pair3)

    val pair4 = 1 to 2 to 3 to 4
    println(pair4)

    val map = mapOf(1 to 'A', 2 to 'B', 3 to 'c')
    println(map)
}

测试输出：

(1, 2)
(1, 2)
((1, 2), 3)
(((1, 2), 3), 4)
{1=A, 2=B, 3=c}

测试Triple （三元）

    val (i, j, k) = Triple(1, "a", 2.0)
    val (a, b) = Pair(4, "5")
    println("$j,$i,$k")
    println("$a,$b")
    println(i.javaClass.name + "," + j.javaClass.name + "," + k.javaClass.name)
    println(a.javaClass.name + "," + b.javaClass.name)

a,1,2.0
4,5
int,java.lang.String,double
int,java.lang.String

我们可以使用自己需要的对应元组，同一个元组元素类型可以不一样，我们出了直接使用变量名引用之外，还可以使用元组引用索引到对应的元素。比如上面的可以是:

    val t = Triple(1, 2, 3)
    println("t.first=${t.first},t.second=${t.second},t.third=${t.third}")
    val p = Pair(1, 2)
    println("p.first=${p.first},p.second=${p.second}")

t.first=1,t.second=2,t.third=3
p.first=1,p.second=2

密封类

密封类用来表示受限的类继承结构：当一个值为有限几种的类型、而不能有任何其他类型时。在某种意义上，他们是枚举类的扩展：枚举类型的值集合也是受限的，但每个枚举常量只存在一个实例，而密封类的一个子类可以有可包含状态的多个实例。

密封类和枚举类比较

类型	枚举类	密封类
相同点	都是受限的结构	都是受限的结构
类个数	继承个数不受限	继承个数受限
实例个数	实例个数受限	实例个数不受限

声明密封类

要声明一个密封类，需要在类名前面添加 sealed 修饰符。虽然密封类也可以有子类，但是所有子类都必须在与密封类自身相同的文件中声明。（在 Kotlin 1.1 之前， 该规则更加严格：子类必须嵌套在密封类声明的内部）。

sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()

（上文示例使用了 Kotlin 1.1 的一个额外的新功能：数据类扩展包括密封类在内的其他类的可能性。 ）

• 一个密封类是自身抽象的，它不能直接实例化并可以有抽象（ abstract ）成员。
• 密封类不允许有非- private 构造函数（其构造函数默认为 private ）。
• 请注意，扩展密封类子类的类（间接继承者）可以放在任何位置，而无需在同一个文件中。

使用密封类的关键好处在于使用 when 表达式 的时候，如果能够验证语句覆盖了所有情况，就不需要为该语句再添加一个 else 子句了。当然，这只有当你用 when 作为表达式（使用结果）而不是作为语句时才有用。

fun eval(expr: Expr): Double = when (expr) {
    is Const -> expr.number
    is Sum -> eval(expr.e1) + eval(expr.e2)
    NotANumber -> Double.NaN
    // 不再需要 `else` 子句，因为我们已经覆盖了所有的情况
}