Kotlin基础（七）：数据类和封闭类

前言

本文主要讲解kotlin数据类（DataClass）和封闭类（SealedClasses），包括使用数据类，对象复制，数据类成员的解构，使用封闭类，以及数据类和封闭类在Android开发中的应用。

---

Kotlin文章列表

Kotlin文章列表: 点击此处跳转查看

---

目录

---

1.1 数据类（DataClass）

Kotlin提供了许多简洁、安全和表达性强的语法特性。其中一个非常有用的特性是数据类（data class）。

数据类是 Kotlin 中用于表示纯数据的一种特殊类。它们通常用于封装数据，并且提供了一些有用的功能，如自动生成的 equals()、hashCode()、toString() 方法，以及 copy() 方法。这些方法允许你轻松地比较、复制和打印数据类的实例。

要声明一个数据类，你可以使用 data 关键字，后面紧跟着类的声明。以下是一个简单的数据类的例子：

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

在上面的例子中，Person 是一个数据类，它有两个属性 name 和 age。Kotlin 会自动为数据类生成以下方法：

• equals(other: Any?)：用于比较两个对象是否相等。
• hashCode()：用于生成对象的哈希码。
• toString()：用于将对象转换为字符串的表示形式。
• copy()：用于复制对象。

你可以使用这些方法来进行对象的比较、复制和打印操作。例如：

val person1 = Person("Alice", 25)
val person2 = Person("Alice", 25)

println(person1 == person2)  // 输出: true

val person3 = person1.copy(age = 30)
println(person3)  // 输出: Person(name=Alice, age=30)

除了自动生成的方法外，数据类还可以继承自其他类、实现接口，以及定义额外的属性和方法。

总结来说，Kotlin 的数据类提供了一种方便的方式来表示纯数据，并自动为你生成一些常用的方法，减少了编写样板代码的工作量。

1.1.1 使用数据类

在 Kotlin 中，使用数据类（data class）非常简单。你可以按照以下步骤使用数据类：

1. 声明数据类：使用 data 关键字声明数据类，并定义它的属性。

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

2. 创建数据类的实例：使用构造函数来创建数据类的实例，并传入相应的属性值。

val person = Person("Alice", 25)

3. 访问数据类的属性：使用点表示法来访问数据类的属性。

println(person.name)  // 输出: Alice
println(person.age)   // 输出: 25

4. 比较数据类的实例：数据类自动生成了 equals() 方法，可以直接用于比较两个对象是否相等。

val person1 = Person("Alice", 25)
val person2 = Person("Alice", 25)

println(person1 == person2)  // 输出: true

5. 复制数据类的实例：数据类自动生成了 copy() 方法，可以用于创建数据类实例的副本，并可以选择性地修改属性的值。

val person3 = person1.copy(age = 30)
println(person3)  // 输出: Person(name=Alice, age=30)

6. 其他自动生成的方法：数据类还自动生成了 hashCode() 和 toString() 方法。hashCode() 方法用于生成对象的哈希码，toString() 方法用于将对象转换为字符串的表示形式。

println(person.hashCode())  // 输出: 根据属性值生成的哈希码
println(person.toString())  // 输出: Person(name=Alice, age=25)

需要注意的是，数据类的主构造函数必须至少有一个参数。如果你希望某个属性不参与比较、复制或生成哈希码，可以将其声明为 val 或 var 之前加上 @Transient 注解。

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

这样，age 属性将被忽略，并不会影响生成的方法。

总之，Kotlin 的数据类提供了一种方便的方式来定义和使用纯数据，并自动为你生成一些常用的方法，简化了对数据的操作。

1.1.2 对象复制

在 Kotlin 中，你可以使用数据类（data class）自动生成的 copy() 方法来复制对象并创建其副本。这个方法允许你选择性地修改副本的属性值。

以下是使用 copy() 方法进行对象复制的示例：

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

val person1 = Person("Alice", 25)
val person2 = person1.copy()

println(person1)  // 输出: Person(name=Alice, age=25)
println(person2)  // 输出: Person(name=Alice, age=25)
println(person1 === person2)  // 输出: false（两个对象不是同一个引用）

在上面的例子中，person1 是一个 Person 对象，通过调用 copy() 方法创建了 person2 的副本。copy() 方法会复制所有属性的值，并返回一个新的对象。

你还可以选择性地修改副本的属性值。可以通过在 copy() 方法中指定新的属性值来实现：

val person3 = person1.copy(age = 30)
println(person3)  // 输出: Person(name=Alice, age=30)

在上面的例子中，person3 是 person1 的副本，但是修改了 age 属性的值。

需要注意的是，copy() 方法只复制数据类的属性值，而不会复制其他相关对象的引用。如果你的数据类包含其他对象类型的属性，它们将会被浅复制，也就是复制引用而不是实际对象。如果需要深复制，需要手动处理相关对象的复制逻辑。

总结来说，使用数据类自动生成的 copy() 方法可以轻松地复制对象并创建副本。你可以选择性地修改副本的属性值，而不影响原始对象。这是 Kotlin 中方便且灵活的对象复制机制。

1.1.3 数据类成员的解构

在 Kotlin 中，数据类（data class）的成员可以通过解构（destructuring）来访问和使用。解构允许你将一个对象的属性拆解为多个独立的变量，以便更方便地使用这些属性。

要使用解构，你可以将一个数据类的实例赋值给多个变量。每个变量的名称与数据类的属性名称相对应。以下是一个使用解构的示例：

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

val person = Person("Alice", 25)
val (name, age) = person

println(name)  // 输出: Alice
println(age)   // 输出: 25

在上面的例子中，我们将 person 对象解构为两个变量 name 和 age。这样，我们可以直接使用这两个变量来访问对象的属性值。

解构不仅限于单个数据类对象，还可以在集合中使用。例如，你可以解构一个包含多个数据类对象的列表：

val people = listOf(
    Person("Alice", 25),
    Person("Bob", 30),
    Person("Charlie", 35)
)

for ((name, age) in people) {
    println("Name: $name, Age: $age")
}

在上面的例子中，我们使用解构在循环中访问 people 列表中每个对象的属性。通过解构，我们可以直接在循环体内使用 name 和 age 变量。

需要注意的是，解构只能用于访问数据类的属性。如果你需要访问其他方法或自定义的成员，仍然需要通过对象名称来调用。

总结来说，Kotlin 中的解构允许你将数据类对象的属性拆解为多个独立的变量，以便更方便地使用这些属性。你可以在赋值语句或循环中使用解构来访问数据类的成员。这是一种简洁、便利的语言特性，可以提高代码的可读性和易用性。

1.1.4 kotlin数据类在Android开发中的应用

在Android开发中，Kotlin数据类非常实用，特别是用于存储和传递数据对象，比如表示网络请求的数据模型、Intent传递的数据对象、RecyclerView的数据项等。下面将分别举例说明Kotlin数据类在这些场景中的应用。

示例1：网络请求数据模型

假设我们有一个简单的用户数据模型，用于表示从服务器获取的用户信息，包含用户名和年龄。

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

示例2：Intent传递数据

当我们需要在Activity之间传递数据时，Kotlin数据类可以帮助我们轻松地创建可序列化的对象，以便Intent传递数据。

在发送端Activity：

import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle

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

class SenderActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_sender)

        val person = Person("John Doe", 30)

        val intent = Intent(this, ReceiverActivity::class.java)
        intent.putExtra("PERSON_DATA", person)
        startActivity(intent)
    }
}

在接收端Activity：

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle

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

class ReceiverActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_receiver)

        val person = intent.getSerializableExtra("PERSON_DATA") as? Person
        if (person != null) {
            // 使用接收到的Person对象进行操作
            // 例如：显示名称和年龄
        }
    }
}

示例3：RecyclerView的数据项

在RecyclerView中，我们经常需要使用数据类来表示每个列表项的数据。

首先，在RecyclerView的适配器中定义一个数据类，用于表示列表项的数据：

data class Item(val title: String, val description: String)

然后，在适配器中使用这个数据类：

class ItemAdapter(private val itemList: List<Item>) : RecyclerView.Adapter<ItemAdapter.ItemViewHolder>() {

    // ... 适配器的其他代码 ...

    override fun onBindViewHolder(holder: ItemViewHolder, position: Int) {
        val currentItem = itemList[position]
        holder.bind(currentItem)
    }

    inner class ItemViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
        fun bind(item: Item) {
            // 在ViewHolder中绑定数据到视图
            itemView.titleTextView.text = item.title
            itemView.descriptionTextView.text = item.description
        }
    }
}

这样，我们就可以在RecyclerView中使用数据类Item来表示每个列表项的数据，并通过适配器将数据绑定到对应的视图上。

总结：
Kotlin数据类在Android开发中广泛用于数据对象的定义和传递。它们简洁、类型安全且提供了自动生成的方法，极大地简化了Android开发中数据处理的代码。在网络请求的数据模型、Intent传递数据以及RecyclerView的数据项等场景中，Kotlin数据类都能发挥重要的作用。

1.2 封闭类（SealedClasses）

1.2.1 使用封闭类

在 Kotlin 中，封闭类（sealed class）是一种特殊的类，用于限制类的继承层级。封闭类的所有子类必须在同一文件中定义，并且不能在类外部继续扩展。

封闭类用于表示一组相关的类或状态，并且通常与模式匹配（pattern matching）一起使用。它可以作为一个类的抽象基类，定义一些通用的行为和属性，然后由其子类实现具体的细节。

以下是一个封闭类的示例：

sealed class Result
data class Success(val data: String) : Result()
data class Error(val message: String) : Result()
object Loading : Result()

在上面的示例中，Result 是一个封闭类。它有三个子类：Success、Error 和 Loading。Success 和 Error 是数据类，它们分别携带了一个属性 data 和 message。Loading 是一个单例对象。

封闭类的优点在于，当你使用 when 表达式（或者 if 表达式）进行模式匹配时，编译器会强制要求你处理所有可能的子类情况。这样可以确保代码的完整性，避免遗漏某些情况。

以下是一个使用封闭类的模式匹配的示例：

fun processResult(result: Result) {
    when (result) {
        is Success -> println("Success: ${result.data}")
        is Error -> println("Error: ${result.message}")
        Loading -> println("Loading...")
    }
}

val result1: Result = Success("Data loaded successfully")
val result2: Result = Error("Failed to load data")
val result3: Result = Loading

processResult(result1)  // 输出: Success: Data loaded successfully
processResult(result2)  // 输出: Error: Failed to load data
processResult(result3)  // 输出: Loading...

在上面的示例中，processResult() 函数接受一个 Result 对象，并使用 when 表达式根据不同的子类情况进行处理。

需要注意的是，封闭类的子类可以定义在封闭类内部，也可以定义在同一文件的顶层。这取决于你的需求和代码的组织结构。

总结来说，封闭类是 Kotlin 中用于限制类的继承层级的一种特殊类。它通常与模式匹配一起使用，可以确保处理所有可能的子类情况，提高代码的安全性和可读性。

1.2.2 kotlin封闭类在Android开发中的应用

在Android开发中，Kotlin的封闭类（Sealed Class）可以用于表示特定状态、状态机或表达式的状态，并且限制这些状态的范围。封闭类非常适用于处理复杂的状态切换或表示一组有限的相关状态。

下面将分别举例说明Kotlin封闭类在Android开发中的两个应用场景：表示加载状态和表达式求值。

示例1：表示加载状态

假设我们有一个简单的数据请求的场景，我们需要表示数据的三种状态：加载中、加载成功和加载失败。

首先，定义一个封闭类DataState来表示这些状态：

sealed class DataState {
    object Loading : DataState()
    data class Success(val data: String) : DataState()
    data class Error(val message: String) : DataState()
}

接下来，在某个ViewModel中使用这个封闭类来表示数据的不同状态：

class DataViewModel : ViewModel() {
    private val _dataState = MutableLiveData<DataState>()
    val dataState: LiveData<DataState>
        get() = _dataState

    fun fetchData() {
        // 模拟数据请求，这里用延时来模拟网络请求的过程
        _dataState.value = DataState.Loading

        // 假设在此处进行实际的数据请求，并根据请求结果更新_dataState的值
        // 如果请求成功，则设置DataState.Success(data)；如果请求失败，则设置DataState.Error(message)
    }
}

接着，在Activity或Fragment中观察DataViewModel中的dataState，根据不同的状态进行相应的UI展示：

class DataActivity : AppCompatActivity() {

    private val dataViewModel: DataViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_data)

        dataViewModel.dataState.observe(this, { dataState ->
            when (dataState) {
                is DataState.Loading -> showLoadingView()
                is DataState.Success -> showData(dataState.data)
                is DataState.Error -> showError(dataState.message)
            }
        })

        fetchData()
    }

    private fun fetchData() {
        dataViewModel.fetchData()
    }

    private fun showLoadingView() {
        // 显示加载中的UI
    }

    private fun showData(data: String) {
        // 显示数据的UI，使用传递过来的data
    }

    private fun showError(message: String) {
        // 显示错误的UI，使用传递过来的错误消息
    }
}

示例2：表达式求值

另一个应用场景是用封闭类来表示表达式的求值结果，例如简单的加法和减法表达式：

sealed class Expression {
    data class Add(val num1: Int, val num2: Int) : Expression()
    data class Subtract(val num1: Int, val num2: Int) : Expression()
}

然后，我们可以定义一个函数来计算这些表达式：

fun evaluateExpression(expression: Expression): Int {
    return when (expression) {
        is Expression.Add -> expression.num1 + expression.num2
        is Expression.Subtract -> expression.num1 - expression.num2
    }
}

在使用时，可以创建不同的表达式实例，并传递给evaluateExpression函数来得到求值结果：

val addExpression = Expression.Add(5, 3)
val subtractExpression = Expression.Subtract(10, 2)

val addResult = evaluateExpression(addExpression) // 结果为 8
val subtractResult = evaluateExpression(subtractExpression) // 结果为 8

总结：
Kotlin封闭类在Android开发中的应用场景有很多，其中上述两个示例是其中的两个常见场景：表示加载状态和表达式求值。通过使用封闭类，我们可以将相关状态或表达式集中在一个类中，并限制这些状态或表达式的范围，从而使代码更加清晰、易于维护。

​