Comparative analysis of sealed classes, enumeration classes and sealed interfaces in Kotlin

In the Kotlin programming language, Sealed Classes, Enum Classes, and Sealed Interfaces are powerful tools for working with a fixed set of types. They play a special role in Kotlin, especially when creating type-safe branching logic. This article aims to compare these three types, explore their characteristics and their respective usage scenarios.

1. Sealed Classes

1. What it is :
   A sealed class is a special class that can have a restricted set of subclasses. Unlike ordinary base classes, all subclasses of a sealed class must be declared in the same file as the sealed class . This restriction makes sealed classes ideal for representing fixed class hierarchies, especially when using when expressions.

2. When to use :
   a. Represent a limited set of states: Sealed classes are an ideal choice when modeling state machines or handling business logic with limited states.
   b. Safe type checking: Using sealed classes can ensure that the when expression covers all possible situations, thereby avoiding missing some branches.

3. Scenario : Represents different states of UI, such as loading, success and error.

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

fun handleUiState(state: UiState) {
    
    
    when (state) {
    
    
        is UiState.Loading -> println("Loading")
        is UiState.Success -> println("Data: ${
      
      state.data}")
        is UiState.Error -> println("Error: ${
      
      state.message}")
    }
}

UiState, as a sealed class, can clearly define the three states that the UI may be in. This design enables the when expression to cover all possible states and ensures type safety.

2. Enum Classes

1. What it is :
   An enumeration class is used to define a fixed collection of values. Each enumeration constant is an instance of an enumeration class, and enumeration classes in Kotlin can contain properties and methods.

2. When to use :
   a. Represent a set of fixed constants: When you need a set of fixed constants , such as direction, status, mode, etc., the enumeration class is a good choice.
   b. Singleton mode: Each enumeration constant is a singleton , suitable for situations where global uniqueness needs to be ensured.

3. Scenario : Define the days of the week.

enum class DayOfWeek {
    
    
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

fun scheduleActivity(day: DayOfWeek) {
    
    
    when (day) {
    
    
        DayOfWeek.SATURDAY, DayOfWeek.SUNDAY -> println("Relax")
        else -> println("Work")
    }
}

DayOfWeek is an enumeration class that represents the seven days of the week. Enumeration classes are used here to define a fixed, limited set of values.

3. Sealed Interfaces

1. What it is :
   Sealed interfaces are a new feature introduced in Kotlin 1.5. Similar to sealed classes, they limit the number of classes that implement the interface. But unlike sealed classes, classes that implement sealed interfaces can be distributed in multiple files.

2. When to use :
   a. Flexible class hierarchy: If you need a more flexible hierarchy that allows interfaces to be implemented in different files , then sealed interfaces are a better choice.
   b. Interface inheritance: Sealed interfaces support inheritance from other interfaces, which provides more flexibility and reusability.

3. Scenario : Define the results of payment operations, success and failure, where failures may be distributed in different files.

sealed interface PaymentResult {
    
    
    object Success : PaymentResult
    interface Error : PaymentResult {
    
    
        val message: String
    }
}

class NetworkError(override val message: String) : PaymentResult.Error
class ValidationError(override val message: String) : PaymentResult.Error

fun handlePaymentResult(result: PaymentResult) {
    
    
    when (result) {
    
    
        is PaymentResult.Success -> println("Payment Successful")
        is PaymentResult.Error -> println("Error: ${
      
      result.message}")
    }
}

PaymentResult is a sealed interface with two implementations: Success and Error. Error itself is an interface that can be implemented in different files, such as NetworkError and ValidationError, providing more flexibility and extensibility.

Through these examples, we can see that sealed classes, enumeration classes, and sealed interfaces in Kotlin make their use more appropriate and efficient in specific scenarios because of their respective characteristics.

Thanks for reading, Best Regards!