Запечатанные классы и интерфейсы

Конструкторы

Сам запечатанный класс всегда является абстрактным классом, поэтому его нельзя инстанцировать напрямую. Однако он может содержать конструкторы или наследовать их. Эти конструкторы предназначены не для создания экземпляров самого запечатанного класса, а для его подклассов. Рассмотрим следующий пример с запечатанным классом Error и несколькими его подклассами, экземпляры которых мы создаём:

sealed class Error(val message: String) {
    class NetworkError : Error("Network failure")
    class DatabaseError : Error("Database cannot be reached")
    class UnknownError : Error("An unknown error has occurred")
}

fun main() {
    val errors = listOf(Error.NetworkError(), Error.DatabaseError(), Error.UnknownError())
    errors.forEach { println(it.message) }
}
// Network failure 
// Database cannot be reached 
// An unknown error has occurred

В запечатанных классах можно использовать классы enum, чтобы представлять состояния константами перечисления и предоставлять дополнительные сведения. Каждая константа перечисления существует только в виде единственного экземпляра, тогда как у подклассов запечатанного класса может быть несколько экземпляров. В примере sealed class Error вместе с несколькими подклассами использует enum для обозначения степени серьёзности ошибки. Конструктор каждого подкласса инициализирует severity и может изменять его состояние:

enum class ErrorSeverity { MINOR, MAJOR, CRITICAL }

sealed class Error(val severity: ErrorSeverity) {
    class FileReadError(val file: File): Error(ErrorSeverity.MAJOR)
    class DatabaseError(val source: DataSource): Error(ErrorSeverity.CRITICAL)
    object RuntimeError : Error(ErrorSeverity.CRITICAL)
    // Additional error types can be added here
}

Конструкторы запечатанных классов могут иметь одну из двух областей видимости: protected (по умолчанию) или private:

sealed class IOError {
    // A sealed class constructor has protected visibility by default. It's visible inside this class and its subclasses 
    constructor() { /*...*/ }

    // Private constructor, visible inside this class only. 
    // Using a private constructor in a sealed class allows for even stricter control over instantiation, enabling specific initialization procedures within the class.
    private constructor(description: String): this() { /*...*/ }

    // This will raise an error because public and internal constructors are not allowed in sealed classes
    // public constructor(code: Int): this() {} 
}

Наследование в мультиплатформенных проектах

В мультиплатформенных проектах действует ещё одно ограничение наследования: прямые подклассы запечатанных классов должны находиться в одном наборе исходного кода. Оно применяется к запечатанным классам без модификаторов expect и actual.

Если запечатанный класс объявлен как expect в общем наборе исходного кода и имеет реализации actual в наборах исходного кода для платформ, то и версии expect, и actual могут иметь подклассы в своих наборах исходного кода. Кроме того, при использовании иерархической структуры можно создавать подклассы в любом наборе исходного кода между объявлениями expect и actual.

Подробнее об иерархической структуре мультиплатформенных проектов.

Управление состоянием в приложениях с пользовательским интерфейсом

Запечатанные классы можно использовать для представления различных состояний пользовательского интерфейса в приложении. Такой подход обеспечивает структурированную и безопасную обработку изменений интерфейса. В этом примере показано, как управлять различными состояниями пользовательского интерфейса:

sealed class UIState { 
    data object Loading : UIState()
    data class Success(val data: String) : UIState()
    data class Error(val exception: Exception) : UIState()
}

fun updateUI(state: UIState) { 
    when (state) {
        is UIState.Loading -> showLoadingIndicator()
        is UIState.Success -> showData(state.data)
        is UIState.Error -> showError(state.exception) 
    }
}

Обработка способов оплаты

В практических бизнес-приложениях часто требуется эффективно обрабатывать различные способы оплаты. Для реализации такой бизнес-логики можно использовать запечатанные классы с выражениями when. Представление различных способов оплаты в виде подклассов запечатанного класса создаёт понятную и удобную для сопровождения структуру обработки транзакций:

sealed class Payment {
    data class CreditCard(val number: String, val expiryDate: String) : Payment()
    data class PayPal(val email: String) : Payment()
    data object Cash : Payment()
}

fun processPayment(payment: Payment) { 
    when (payment) {
        is Payment.CreditCard -> processCreditCardPayment(payment.number, payment.expiryDate)
        is Payment.PayPal -> processPayPalPayment(payment.email)
        is Payment.Cash -> processCashPayment() 
    }
}

Payment — это запечатанный класс, представляющий различные способы оплаты в системе электронной коммерции: CreditCard, PayPal и Cash. Каждый подкласс может иметь собственные свойства, например number и expiryDate для CreditCard и email для PayPal.

Функция processPayment() показывает, как обрабатывать различные способы оплаты. Такой подход гарантирует, что будут учтены все возможные типы оплаты, а система останется гибкой и позволит добавлять новые способы оплаты в будущем.

Обработка запросов и ответов API

Запечатанные классы и интерфейсы можно использовать для реализации системы аутентификации пользователей, обрабатывающей запросы и ответы API. Система аутентификации пользователей поддерживает вход и выход из системы. Запечатанный интерфейс ApiRequest определяет конкретные типы запросов: LoginRequest для входа и LogoutRequest для выхода из системы. Запечатанный класс ApiResponse инкапсулирует различные сценарии ответа: UserSuccess с данными пользователя, UserNotFound для отсутствующих пользователей и Error для любых сбоев. Функция handleRequest обрабатывает эти запросы типобезопасным способом с помощью выражения when, а getUserById имитирует получение данных пользователя:

// Import necessary modules
import io.ktor.server.application.*
import io.ktor.server.resources.*

import kotlinx.serialization.*

// Define the sealed interface for API requests using Ktor resources
@Resource("api")
sealed interface ApiRequest

@Serializable
@Resource("login")
data class LoginRequest(val username: String, val password: String) : ApiRequest


@Serializable
@Resource("logout")
object LogoutRequest : ApiRequest

// Define the ApiResponse sealed class with detailed response types
sealed class ApiResponse {
    data class UserSuccess(val user: UserData) : ApiResponse()
    data object UserNotFound : ApiResponse()
    data class Error(val message: String) : ApiResponse()
}

// User data class to be used in the success response
data class UserData(val userId: String, val name: String, val email: String)

// Function to validate user credentials (for demonstration purposes)
fun isValidUser(username: String, password: String): Boolean {
    // Some validation logic (this is just a placeholder)
    return username == "validUser" && password == "validPass"
}

// Function to handle API requests with detailed responses
fun handleRequest(request: ApiRequest): ApiResponse {
    return when (request) {
        is LoginRequest -> {
            if (isValidUser(request.username, request.password)) {
                ApiResponse.UserSuccess(UserData("userId", "userName", "userEmail"))
            } else {
                ApiResponse.Error("Invalid username or password")
            }
        }
        is LogoutRequest -> {
            // Assuming logout operation always succeeds for this example
            ApiResponse.UserSuccess(UserData("userId", "userName", "userEmail")) // For demonstration
        }
    }
}

// Function to simulate a getUserById call
fun getUserById(userId: String): ApiResponse {
    return if (userId == "validUserId") {
        ApiResponse.UserSuccess(UserData("validUserId", "John Doe", "john@example.com"))
    } else {
        ApiResponse.UserNotFound
    }
    // Error handling would also result in an Error response.
}

// Main function to demonstrate the usage
fun main() {
    val loginResponse = handleRequest(LoginRequest("user", "pass"))
    println(loginResponse)

    val logoutResponse = handleRequest(LogoutRequest)
    println(logoutResponse)

    val userResponse = getUserById("validUserId")
    println(userResponse)

    val userNotFoundResponse = getUserById("invalidId")
    println(userNotFoundResponse)
}