Sealed Classes & Enums

Reviewed & published by Brayan K

Kotlin is a modern, concise language that lets you model a fixed set of possibilities precisely — enums for constant values and sealed classes for restricted hierarchies where each case carries its own data.

Part of the free Kotlin course at LearnCodingFast — hands-on lessons with worked examples and the output they print, plus practice exercises and a quick quiz.

By the end of this lesson you'll define enums with data and methods, build sealed class hierarchies, and handle them exhaustively with when.

What You'll Learn in This Lesson

• Declaring enums with named constants
• Enums that hold data and methods
• Iterating values() and using name/ordinal
• Sealed classes for restricted hierarchies
• Cases carrying different data via data classes and object
• Exhaustive when with no else

1️⃣ Enums

An enum class defines a fixed set of named constants. Each constant can carry data (passed to a constructor), and the enum can have shared properties and methods. You can iterate all values and use name and ordinal.

// An enum is a fixed set of named constants.
enum class Direction {
    NORTH, SOUTH, EAST, WEST
}

// Enums can hold data and define methods.
enum class Planet(val gravity: Double) {
    EARTH(9.8),
    MARS(3.7),
    MOON(1.6);

    fun weightOf(massKg: Double): Double = massKg * gravity
}

fun main() {
    val d = Direction.NORTH
    println(d)                          // -> NORTH
    println(d.name)                     // -> NORTH (the constant's name)
    println(d.ordinal)                  // -> 0 (its position)

    // Iterate every value:
    for (p in Planet.values()) {
        println("${p.name}: ${p.weightOf(10.0)} N")
    }

    // when over an enum is exhaustive — no else needed:
    val label = when (d) {
        Direction.NORTH -> "up"
        Direction.SOUTH -> "down"
        Direction.EAST -> "right"
        Direction.WEST -> "left"
    }
    println(label)                      // -> up
}

Because an enum's cases are fixed, a when over it is exhaustive — the compiler knows you covered every direction, so no else is needed.

2️⃣ Sealed Classes

A sealed class has a closed set of subclasses, all known to the compiler. Unlike an enum, each case can carry different data — making sealed classes ideal for modelling outcomes like success, error, and loading.

// A SEALED class has a fixed set of subclasses, all known to the compiler.
// Unlike an enum, each case can carry DIFFERENT data.
sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
    object Loading : Result()           // a single shared instance
}

fun handle(result: Result): String = when (result) {
    is Result.Success -> "Got: ${result.data}"   // smart-cast to Success
    is Result.Error -> "Failed: ${result.message}"
    Result.Loading -> "Please wait..."
    // No else needed — the compiler knows all cases are covered.
}

fun main() {
    println(handle(Result.Success("user data")))
    println(handle(Result.Error("not found")))
    println(handle(Result.Loading))
}

The when in handle needs no else, and each is branch smart-casts the result so you can read its specific data directly.

Your turn. Replace the TODO, then run and compare.

// 🎯 YOUR TURN — replace each TODO then run main()

enum class TrafficLight { RED, YELLOW, GREEN }

fun action(light: TrafficLight): String = when (light) {
    TrafficLight.RED -> "Stop"
    TrafficLight.YELLOW -> "Slow"
    TrafficLight.GREEN -> "TODO"        // 👉 replace TODO with "Go"
}

fun main() {
    for (l in TrafficLight.values()) {
        println("${l.name}: ${action(l)}")
    }
    // ✅ Expected:
    //    RED: Stop
    //    YELLOW: Slow
    //    GREEN: Go
}

Mini-Challenge: A Payment Outcome

Model three different outcomes with a sealed class and handle them exhaustively.

// 🎯 MINI-CHALLENGE: model a payment outcome.
// Save as Payment.kt and run main().
//
// 1. Define sealed class Payment with subclasses:
//    - data class Paid(val amount: Int) : Payment()
//    - data class Declined(val reason: String) : Payment()
//    - object Pending : Payment()
// 2. Write fun describe(p: Payment): String using a 'when' over the
//    sealed type (no else): Paid -> "Paid <amount>",
//    Declined -> "Declined: <reason>", Pending -> "Pending".
// 3. In main(), print describe() for one of each.
//
// ✅ Example output:
//    Paid 50
//    Declined: low funds
//    Pending

fun main() {
    // your code here
}

Common Errors (and the fix)

• "'when' must be exhaustive" — You missed a case. Add the remaining branches (or an else if you can't cover all).
• Forgetting the ; after enum constants — When an enum also has methods, a semicolon separates the constants from the members.
• Calling a constructor on an object case — A singleton case like Loading takes no (); reference it directly.
• Subclass outside the sealed file — Sealed subclasses must be in the same file/module so the compiler can see them all.

Pro Tips

• 💡 Assign the when result — when used as an expression, the compiler enforces exhaustiveness for you.
• 💡 Sealed for state machines: they shine for UI states (Loading/Success/Error) and parser results.
• 💡 entries over values(): newer Kotlin offers EnumName.entries as a modern alternative to values().

📋 Quick Reference — Sealed & Enums

🎉 Lesson Complete!

• ✅ Enums are a fixed set of named constants, optionally with data and methods
• ✅ Sealed classes are restricted hierarchies whose cases carry different data
• ✅ object cases are singletons with no data
• ✅ when over enums/sealed is exhaustive — no else
• ✅ is branches smart-cast to the specific case

Practice quiz

Continue this course

• Previous: Inheritance & Interfaces
• Next: Generics — Write reusable, type-safe code with generic classes and functions
• Quick reference: Kotlin cheat sheet

Frequently asked questions

When should I use an enum versus a sealed class?

Use an enum when you have a fixed set of constant values that are essentially the same shape — like directions, days of the week, or status flags — optionally each carrying the same kind of data. Use a sealed class when your fixed set of cases need to carry different data per case, like a Result that is either Success(data), Error(message), or Loading. Enums are a list of singletons; sealed classes are a restricted hierarchy where each subclass can have its own properties.

Why don't I need an else branch in a when over a sealed class or enum?

Because the compiler knows the complete set of possible cases. An enum has a finite list of constants, and a sealed class's subclasses must all be declared in the same file (or module), so the compiler can verify your when covers every one. When it is exhaustive, no else is required — and if you later add a new case, the compiler will flag every when that no longer covers all options, helping you update them.

What is the 'object' keyword doing inside a sealed class?

object declares a singleton — a single, shared instance with no constructor parameters. Inside a sealed class it is ideal for cases that carry no data, like Loading or Pending: there's only ever one Loading, so a singleton is exactly right. Cases that do carry data are usually data classes instead, so each instance can hold its own values.

Can enums have behaviour, not just values?

Yes. Enum constants can take constructor arguments (like Planet's gravity) and the enum class can declare properties and methods that all constants share, such as weightOf(). You can even give individual constants their own overridden method implementations using an anonymous body. This makes enums far more powerful than plain integer constants in older languages.