Blog

Why we compare Sealed and Enum Classes in Kotlin. Are these really related ?

Answer is YES. Enums and sealed classes are related in the sense that they both provide mechanisms for creating restricted sets of options or types in Kotlin. Enums and sealed classes share the concept of defining restricted sets of options or types, but they differ in their flexibility and intended usage. Enums are more suitable for representing simple lists of constant values, while sealed classes are more powerful, allowing for defining hierarchies of related types with varying behaviour and data.

Relationship:

1. Limited Options: Both enums and sealed classes allow you to define a restricted set of options or types. Enums restrict instances to a fixed set of values, while sealed classes restrict inheritance to a fixed set of subclasses.
2. Compile-time Safety: Both enums and sealed classes provide compile-time safety. With enums, the compiler ensures that you only use valid enum values. Similarly, with sealed classes, the compiler can enforce exhaustive checks when used in when expressions.

Differences:

1. Flexibility: Enums are limited to defining a set of constant values with no additional behavior or data associated with each value. Sealed classes, on the other hand, allow for defining a hierarchy of related types with varying behavior and data.
2. Inheritance vs. Value Types: Enums primarily deal with defining value types (constants), while sealed classes deal with defining a hierarchy of types with inheritance relationships.
3. Syntax and Usage: Enums are declared using the enum class syntax, while sealed classes are declared using the sealed class syntax.

Enum Class:

1. Purpose: Enum classes are used to represent a fixed set of constants.
2. Values: Each value of an enum class is an object. Enums can have properties, methods, and implement interfaces.
3. Usage: Enums are commonly used to represent things like days of the week, colors, or states.

enum class Direction {
    NORTH, SOUTH, EAST, WEST
}

fun move(direction: Direction) {
    // Handle movement logic
}

move(Direction.NORTH)

Sealed Class:

1. Purpose: Sealed classes are used to represent restricted class hierarchies.
2. Inheritance: Sealed classes can have multiple instances (subclasses), but all of these instances must be declared within the same file where the sealed class is declared.
3. Extensibility: Sealed classes are often used in conjunction with when expressions for exhaustive checks, ensuring that all subclasses are covered.

sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
}

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

Comparison:

• Enums are more suitable for representing a fixed set of related constants.
• Sealed classes are more suitable for representing a restricted hierarchy of types, where the types are known and finite but can have different data and behavior.

Some limitations of enums that can be solved by sealed classes include:

1. Inability to store additional data: Enums cannot have additional properties beyond the predefined values. Sealed classes allow each subclass to have its own properties, enabling more flexibility in data representation.
2. Inability to have behavior: Enums cannot contain methods or behaviors. Sealed classes can have methods and behaviors associated with each subclass, allowing for more complex functionality.
3. Inflexibility in extending functionality: Enums cannot be extended or modified at runtime. Sealed classes can be extended with new subclasses, providing more flexibility for future changes or extensions.
4. Limited pattern matching: While enums support pattern matching, sealed classes offer more advanced pattern matching capabilities, especially when combined with other features like exhaustive when clauses in languages like Kotlin.

In summary, use enum class when you have a fixed set of constants, and use sealed class when you have a restricted hierarchy of types.