解锁Kotlin：数据类与密封类的奇妙之旅

小码哥_常
11 阅读10分钟

解锁Kotlin：数据类与密封类的奇妙之旅

开篇：代码的烦恼与 Kotlin 的曙光

在 Android 开发的漫长旅程中，相信不少开发者都在 Java 的世界里历经了 “千辛万苦”。就拿定义一个简单的数据模型来说，在 Java 中，我们往往要写大量的样板代码。比如定义一个用户类 User，不仅要声明字段，还要手动编写构造函数、getter 和 setter 方法、equals 和 hashCode 方法，甚至 toString 方法，以满足日常开发中的各种需求，像对象比较、日志输出等。


public class User {
    private String name;
    private int age;
    private String email;

    public User(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age &&
                Objects.equals(name, user.name) &&
                Objects.equals(email, user.email);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, email);
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                '}';
    }
}

这样一套操作下来，代码量剧增，不仅编写时繁琐，后期维护也变得困难重重，稍有不慎，就可能在这些重复的代码中埋下隐患。

而在状态管理方面，Java 缺乏类型安全的支持，也常常让开发者们头疼不已。假设我们要处理一个网络请求的不同状态，比如加载中、成功、失败，传统的做法可能是定义几个常量来表示这些状态，然后在代码中通过大量的条件判断来处理不同状态下的逻辑 。


public class NetworkRequest {
    public static final int LOADING = 0;
    public static final int SUCCESS = 1;
    public static final int FAILURE = 2;

    private int status;

    public NetworkRequest(int status) {
        this.status = status;
    }

    public void handleRequest() {
        if (status == LOADING) {
            // 处理加载中的逻辑
            System.out.println("请求正在加载...");
        } else if (status == SUCCESS) {
            // 处理请求成功的逻辑
            System.out.println("请求成功！");
        } else if (status == FAILURE) {
            // 处理请求失败的逻辑
            System.out.println("请求失败！");
        }
    }
}

这种方式很容易出错，因为常量只是简单的整数值，没有任何类型信息，一旦在代码中不小心传递了错误的值，编译器也无法及时发现，直到运行时才可能暴露问题，调试起来十分麻烦。

Kotlin 的出现，就像是一道曙光，照亮了 Android 开发者们前行的道路。它以简洁、安全、高效等特性，为我们解决了 Java 时代的诸多痛点。其中，数据类和密封类就是 Kotlin 赋予开发者的两个强大武器，它们在简化代码和增强类型安全方面表现卓越 。接下来，就让我们深入探索 Kotlin 数据类与密封类的奇妙世界，看看它们是如何让我们的代码变得更加优雅和健壮的吧！

一、Kotlin 数据类：数据的高效载体

（一）定义与基本语法

在 Kotlin 中，数据类是一种专门用于存储数据的特殊类，它的定义非常简洁，只需使用data关键字修饰类名即可。以一个简单的User类为例：


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

在上述代码中，User数据类有两个属性，name和age，分别表示用户的姓名和年龄。val关键字表示这些属性是只读的，在对象创建后不能被重新赋值 。这种简洁的定义方式，相比 Java 中定义一个包含相同属性的类，省去了大量的样板代码，让开发者能够更专注于数据本身 。

（二）自动生成的方法

Kotlin 的数据类之所以强大，很大程度上得益于编译器自动为其生成的一系列实用方法。

  • equals () 和 hashCode () 方法：这两个方法是用于对象比较的关键。equals()方法基于数据类的属性值来判断两个对象是否相等，而hashCode()方法则根据属性值生成哈希码，以便在哈希集合（如HashSet、HashMap）中正确地存储和查找对象。例如：

val user1 = User("Alice", 25)
val user2 = User("Alice", 25)
println(user1 == user2) // true，基于内容比较
println(user1.hashCode() == user2.hashCode()) // true，相同内容生成相同哈希码
  • toString () 方法：toString()方法生成一个包含类名和所有属性名称及值的格式化字符串，方便调试和日志输出。比如：

val user = User("Bob", 30)
println(user) // 输出：User(name=Bob, age=30)
  • copy () 方法：copy()方法用于创建一个对象的浅拷贝，同时可以修改部分属性的值，而保持其他属性不变。这在需要对不可变对象进行局部修改时非常有用。例如：

val original = User("Charlie", 40)
val modified = original.copy(age = 41)
println(original) // User(name=Charlie, age=40)
println(modified) // User(name=Charlie, age=41)
  • componentN () 函数：数据类会为每个属性按声明顺序生成对应的component1()、component2()……componentN()函数，这些函数用于解构声明，后面会详细介绍。

（三）解构声明

Kotlin 的数据类支持解构声明，这是一种非常便捷的语法糖，可以让我们方便地获取数据类对象的属性值，并将其赋值给多个独立的变量。例如：


val user = User("Diana", 35)
val (name, age) = user
println("Name: $name, Age: $age") // Name: Diana, Age: 35

在上述代码中，user对象被解构为name和age两个变量，其背后实际上是调用了user.component1()和user.component2()函数。解构声明在遍历集合、处理函数返回多个值等场景中都能极大地简化代码 。比如，在遍历一个包含User对象的列表时：


val users = listOf(User("Eve", 28), User("Frank", 32))
for ((name, age) in users) {
    println("$name is $age years old")
}

（四）限制条件

虽然数据类带来了诸多便利，但它也有一些限制条件：

  • 主构造函数必须至少有一个参数。如果没有参数，数据类就失去了作为数据载体的意义，编译器也无法为其生成有用的方法。

  • 主构造函数的参数必须标记为val或var。这是因为这些参数需要被用来生成equals、hashCode和toString等方法，如果不标记为val或var，它们就只是普通的构造函数参数，而不是类的属性。

  • 数据类不能是抽象类、开放类（open）、密封类或内部类。这是为了保证编译器生成的方法行为一致且不会被父类干扰。例如，不能定义如下的数据类：


// 错误示例
abstract data class AbstractUser(val name: String) // 不能是抽象类
open data class OpenUser(val name: String) // 不能是开放类
sealed data class SealedUser(val name: String) // 不能是密封类
class Outer {
    inner data class InnerUser(val name: String) // 不能是内部类
}

（五）常见用途

在 Android 开发中，数据类有着广泛的应用场景：

  • 作为模型类：在 MVVM 架构中，数据类常被用作数据模型，用于表示从网络或数据库获取的数据。比如，从服务器获取用户信息时，可以定义如下数据类：

data class UserInfo(val id: Int, val name: String, val email: String)
  • 传输对象：在不同层之间传递数据时，数据类非常合适。例如，在网络请求中，将服务器返回的数据封装成数据类对象，方便在应用内传递和处理 。假设我们有一个获取商品列表的网络请求，响应数据可以用数据类表示为：

data class ProductListResponse(val products: List<Product>, val totalCount: Int)
data class Product(val id: String, val name: String, val price: Double)
  • 返回多个值：当一个函数需要返回多个值时，数据类可以提高代码的可读性。比如，一个函数用于验证用户输入，返回验证结果和错误信息：

data class ValidationResult(val isValid: Boolean, val errorMessage: String?)

fun validateInput(username: String, password: String): ValidationResult {
    if (username.isNotEmpty() && password.length >= 6) {
        return ValidationResult(true, null)
    } else {
        return ValidationResult(false, "用户名不能为空，密码长度不能小于6位")
    }
}

通过上述介绍，我们可以看到 Kotlin 数据类在简化代码、提高开发效率方面的强大功能。它让我们告别了繁琐的样板代码，专注于业务逻辑的实现 。接下来，让我们继续探索 Kotlin 的密封类，看看它又能为我们带来哪些惊喜。

二、Kotlin 密封类：状态的精准掌控者

（一）定义与基本概念

在 Kotlin 中，密封类是一种特殊的类，它用于表示受限的类层次结构 。使用sealed关键字来声明一个密封类，它的所有直接子类必须在编译期已知，并且这些子类通常需要定义在与密封类相同的文件或模块中（Kotlin 1.5 及以上版本支持同一模块内同一包下不同文件定义子类 ）。例如，我们定义一个表示网络请求结果的密封类NetworkResult：


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

在上述代码中，NetworkResult是一个密封类，它有三个直接子类：Success表示请求成功，携带成功返回的数据；Error表示请求失败，携带错误信息；Loading表示请求正在加载中。由于这些子类在编译期是确定的，编译器可以对它们进行更严格的类型检查 。

（二）特点与优势

  1. 子类声明限制：所有直接子类必须在同一文件（Kotlin 1.5 前严格要求）或同一模块的同一包下（Kotlin 1.5 及之后）声明。这确保了密封类的继承体系是封闭的，不会在运行时出现意外的子类扩展，提高了代码的可维护性和安全性。例如，如果在另一个文件中尝试定义NetworkResult的新子类，编译器会报错。

  2. 抽象特性：密封类本身是抽象的，不能直接实例化。这符合它作为受限类层次结构的设计理念，它主要是为了定义一组相关的子类，而不是创建自身的实例。比如，不能直接创建NetworkResult的对象：val result = NetworkResult()，这会导致编译错误。

  3. 类型安全的 when 表达式：当在when表达式中使用密封类时，如果覆盖了所有的子类情况，编译器可以检查到这一点，从而允许省略else分支。这大大增强了代码的健壮性，避免了因遗漏分支而导致的运行时错误。例如：


fun handleNetworkResult(result: NetworkResult) {
    when (result) {
        is NetworkResult.Success -> println("成功，数据: ${result.data}")
        is NetworkResult.Error -> println("失败，信息: ${result.message}")
        NetworkResult.Loading -> println("正在加载...")
    }
    // 这里没有else分支，编译器不会报错，因为已经覆盖了所有的NetworkResult子类情况
}
  1. 灵活的数据携带：密封类的子类可以是数据类、普通类或对象，这使得它们能够根据不同的情况携带不同类型的数据 。比如Success子类是数据类，可以携带网络请求成功返回的数据；Error子类也是数据类，携带错误信息，这种灵活性是枚举类所不具备的，枚举类的每个实例结构通常是相同的，且不便于携带复杂数据 。

（三）使用场景

  1. API 响应处理：在处理 API 请求的响应时，密封类非常有用。可以用不同的子类表示请求的不同状态，如成功、失败、加载中。例如：

sealed class ApiResponse<out T> {
    data class Success<T>(val data: T) : ApiResponse<T>()
    data class Error(val code: Int, val message: String) : ApiResponse<Nothing>()
    object Loading : ApiResponse<Nothing>()
}

fun handleApiResponse(response: ApiResponse<String>) {
    when (response) {
        is ApiResponse.Success -> println("API请求成功，数据: ${response.data}")
        is ApiResponse.Error -> println("API请求失败，代码: ${response.code}，信息: ${response.message}")
        ApiResponse.Loading -> println("API请求正在加载...")
    }
}
  1. UI 状态管理：在 Android 开发中，管理 UI 的状态是常见的需求。可以使用密封类来定义 UI 可能处于的不同状态，如加载、显示内容、显示错误等。例如：

sealed class UiState {
    data class Content(val items: List<String>) : UiState()
    data class Error(val message: String) : UiState()
    object Loading : UiState()
    object Empty : UiState()
}

class UiViewModel {
    private val _uiState = MutableStateFlow<UiState>(UiState.Loading)
    val uiState = _uiState.asStateFlow()

    fun loadData() {
        // 模拟数据加载成功
        _uiState.value = UiState.Content(listOf("Item 1", "Item 2"))
    }
}

// 在UI中处理状态
uiViewModel.uiState.collect { state ->
    when (state) {
        is UiState.Content -> showContent(state.items)
        is UiState.Error -> showError(state.message)
        UiState.Loading -> showLoading()
        UiState.Empty -> showEmptyView()
    }
}
  1. 表达式树：在编译器或解释器等场景中，需要表示表达式树。密封类可以很好地用于定义不同类型的表达式节点。例如，定义一个简单的算术表达式树：

sealed class Expr {
    data class Number(val value: Int) : Expr()
    data class Sum(val left: Expr, val right: Expr) : Expr()
    data class Multiply(val left: Expr, val right: Expr) : Expr()
}

fun eval(expr: Expr): Int {
    when (expr) {
        is Expr.Number -> return expr.value
        is Expr.Sum -> return eval(expr.left) + eval(expr.right)
        is Expr.Multiply -> return eval(expr.left) * eval(expr.right)
    }
}

val expression = Expr.Sum(Expr.Number(2), Expr.Multiply(Expr.Number(3), Expr.Number(4)))
println(eval(expression)) // 输出: 14
  1. 导航 / 路由：在应用程序中，管理页面导航或路由时，密封类可以用来定义不同的屏幕或路由。例如：

sealed class Screen(val route: String) {
    object Home : Screen("home")
    object Profile : Screen("profile")
    data class Details(val id: String) : Screen("details/$id")
    data class Settings(val section: String) : Screen("settings?section=$section")
}

fun navigateTo(screen: Screen) {
    when (screen) {
        Screen.Home -> // 导航到首页的逻辑
        Screen.Profile -> // 导航到个人资料页的逻辑
        is Screen.Details -> // 导航到详情页，带参数的逻辑
        is Screen.Settings -> // 导航到设置页，带参数的逻辑
    }
}

（四）进阶用法

  1. 密封接口：从 Kotlin 1.5 开始，支持密封接口。密封接口和密封类类似，也是用于限制实现的范围 。所有实现密封接口的类型必须在编译期已知，并且通常在同一文件或模块中。例如：

sealed interface Result<out T> {
    data class Success<T>(val data: T) : Result<T>
    data class Failure(val error: Throwable) : Result<Nothing>
    object Loading : Result<Nothing>
}

密封接口在需要更灵活的多态性时很有用，因为一个类可以实现多个接口，而只能继承一个类。 2. 嵌套密封类：密封类可以嵌套在其他密封类中，形成更复杂的受限层次结构 。例如：


sealed class Vehicle {
    sealed class Car : Vehicle() {
        data class Sedan(val seats: Int) : Car()
        data class SUV(val offroad: Boolean) : Car()
    }
    sealed class Bike : Vehicle() {
        object MountainBike : Bike()
        object RoadBike : Bike()
    }
}

在上述代码中，Vehicle是一个密封类，它包含两个嵌套的密封类Car和Bike，每个嵌套的密封类又有自己的子类，这种结构在表示复杂的领域模型时非常方便。 3. 结合泛型：密封类可以与泛型结合使用，以提供更通用的解决方案。例如前面提到的ApiResponse密封类，它使用泛型来表示成功响应时的数据类型：


sealed class ApiResponse<out T> {
    data class Success<T>(val data: T) : ApiResponse<T>()
    data class Error(val code: Int, val message: String) : ApiResponse<Nothing>()
    object Loading : ApiResponse<Nothing>()
}

这样，ApiResponse可以处理不同类型数据的 API 响应，增强了代码的复用性 。通过对密封类的深入了解，我们看到了它在解决特定编程问题时的强大能力，与数据类一起，它们为 Kotlin 开发者提供了更高效、安全的编程工具 。

三、实战演练：电商应用中的数据类与密封类

（一）数据类重构商品 DTO

在电商应用中，商品详情数据的传输和处理是非常常见的场景。假设我们有一个商品详情的数据传输对象（DTO），在 Java 中，其定义可能如下：


import java.math.BigDecimal;
import java.util.List;

public class ProductDTO {
    private String id;
    private String name;
    private BigDecimal price;
    private List<String> tags;

    public ProductDTO(String id, String name, BigDecimal price, List<String> tags) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.tags = tags;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public BigDecimal getPrice() {
        return price;
    }

    public void setPrice(BigDecimal price) {
        this.price = price;
    }

    public List<String> getTags() {
        return tags;
    }

    public void setTags(List<String> tags) {
        this.tags = tags;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ProductDTO that = (ProductDTO) o;
        return id.equals(that.id) &&
                name.equals(that.name) &&
                price.equals(that.price) &&
                tags.equals(that.tags);
    }

    @Override
    public int hashCode() {
        return 31 * id.hashCode() + 31 * name.hashCode() + 31 * price.hashCode() + 31 * tags.hashCode();
    }

    @Override
    public String toString() {
        return "ProductDTO{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", price=" + price +
                ", tags=" + tags +
                '}';
    }
}

这段代码中，为了实现基本的数据存储和对象比较等功能，我们编写了大量的样板代码，包括构造函数、getter 和 setter 方法、equals 和 hashCode 方法以及 toString 方法 。不仅代码冗长，而且维护起来十分困难，一旦某个字段的类型或逻辑发生变化，需要在多个地方进行修改。

使用 Kotlin 数据类进行重构后，代码变得简洁明了：


import java.math.BigDecimal

data class Product(
    val id: String,
    val name: String,
    val price: BigDecimal,
    val tags: List<String> = emptyList()
)

通过使用data关键字，Kotlin 编译器自动为我们生成了构造函数、equals、hashCode、toString 和 copy 等方法 。这不仅减少了大量的重复代码，还提高了代码的可读性和可维护性 。比如，在进行对象比较时，我们可以直接使用==操作符，它会基于对象的属性值进行比较：


val product1 = Product("1", "手机", BigDecimal("2999.00"), listOf("数码", "电子产品"))
val product2 = Product("1", "手机", BigDecimal("2999.00"), listOf("数码", "电子产品"))
println(product1 == product2) // true

在需要修改对象的部分属性时，使用copy方法非常方便：


val discountedProduct = product1.copy(price = product1.price.multiply(BigDecimal("0.9")))
println(discountedProduct) // Product(id=1, name=手机, price=2699.1, tags=[数码, 电子产品])

此外，Kotlin 的数据类在空安全方面也有很好的支持。属性默认是非空的，如果需要允许为空，需要显式声明为可空类型，这在一定程度上避免了空指针异常的出现 。比如，如果name字段允许为空，应该声明为val name: String? 。

（二）密封类重构订单状态管理

在电商应用中，订单状态的管理是一个重要的环节。传统的 Java 代码中，可能会使用常量和条件判断来管理订单状态，如下所示：


public class Order {
    public static final int STATE_CREATED = 0;
    public static final int STATE_PAID = 1;
    public static final int STATE_SHIPPED = 2;
    public static final int STATE_DELIVERED = 3;
    public static final int STATE_CANCELED = 4;

    private int state;

    public Order(int state) {
        this.state = state;
    }

    public void handleOrderState() {
        switch (state) {
            case STATE_CREATED:
                System.out.println("订单已创建");
                break;
            case STATE_PAID:
                System.out.println("订单已支付");
                break;
            case STATE_SHIPPED:
                System.out.println("订单已发货");
                break;
            case STATE_DELIVERED:
                System.out.println("订单已送达");
                break;
            case STATE_CANCELED:
                System.out.println("订单已取消");
                break;
            default:
                System.out.println("未知订单状态");
        }
    }
}

这种方式存在一些问题，比如类型不安全，状态值只是简单的整数，容易出现传递错误值的情况；而且当需要新增状态时，需要在多个地方修改代码，容易遗漏 。

使用 Kotlin 密封类重构后，可以更好地管理订单状态：


sealed class OrderState {
    object Created : OrderState()
    object Paid : OrderState()
    object Shipped : OrderState()
    object Delivered : OrderState()
    object Canceled : OrderState()
}

class Order(private val state: OrderState) {
    fun handleOrderState() {
        when (state) {
            OrderState.Created -> println("订单已创建")
            OrderState.Paid -> println("订单已支付")
            OrderState.Shipped -> println("订单已发货")
            OrderState.Delivered -> println("订单已送达")
            OrderState.Canceled -> println("订单已取消")
        }
    }
}

在上述代码中，OrderState是一个密封类，它的所有直接子类都在编译期已知，并且通过when表达式处理订单状态时，编译器可以检查是否覆盖了所有的状态分支 。如果遗漏了某个状态，编译器会报错，这大大增强了代码的健壮性 。比如，如果后续需要新增一个Returned（已退货）状态，只需要在OrderState密封类中新增一个子类：


sealed class OrderState {
    object Created : OrderState()
    object Paid : OrderState()
    object Shipped : OrderState()
    object Delivered : OrderState()
    object Canceled : OrderState()
    object Returned : OrderState()
}

此时，所有使用when表达式处理OrderState的地方都会编译失败，提示开发者需要处理新增的Returned状态，从而避免了因状态扩展而导致的逻辑错误 。此外，密封类的子类还可以是数据类，用于携带更多的状态相关数据。例如，如果在订单支付成功时，需要返回支付凭证等信息，可以将Paid子类定义为数据类：


sealed class OrderState {
    object Created : OrderState()
    data class Paid(val paymentProof: String) : OrderState()
    object Shipped : OrderState()
    object Delivered : OrderState()
    object Canceled : OrderState()
    object Returned : OrderState()
}

class Order(private val state: OrderState) {
    fun handleOrderState() {
        when (state) {
            OrderState.Created -> println("订单已创建")
            is OrderState.Paid -> println("订单已支付，支付凭证: ${state.paymentProof}")
            OrderState.Shipped -> println("订单已发货")
            OrderState.Delivered -> println("订单已送达")
            OrderState.Canceled -> println("订单已取消")
            OrderState.Returned -> println("订单已退货")
        }
    }
}

通过这样的方式，我们可以更灵活、更安全地管理订单状态，使代码更易于维护和扩展 。

avatar
文章
阅读
粉丝