Data, enum and sealed classes, and objects

Data classes

Many classes just hold data: a Product, a Contact, an API response. For these, mark the class with data. Kotlin then writes useful functions for you, based on the properties in the primary constructor.

data class Product(val id: Int, val name: String, val price: Int)

fun main() {
    val a = Product(1, "Kurta", 899)
    val b = Product(1, "Kurta", 899)
    println(a)              // Product(id=1, name=Kurta, price=899)
    println(a == b)         // true: compares the data, not the memory address
    val sale = a.copy(price = 699)     // a new object with one change
    val (id, name) = sale              // destructuring
    println("$id $name ${sale.price}")  // 1 Kurta 699
}

copy is important in Android: UI state is usually held in immutable data classes, and you create a changed version with copy instead of changing the original. That makes it easy for the UI to notice changes.

Only properties declared in the primary constructor take part in these generated functions. A data class must have at least one such property, and it cannot be open, abstract or sealed.

Enum classes

enum class PaymentMode(val label: String) {
    UPI("UPI"), CARD("Card"), CASH("Cash on delivery");

    fun isOnline() = this != CASH
}

fun main() {
    val m = PaymentMode.UPI
    println(m.label)          // UPI
    println(m.isOnline())     // true
    println(PaymentMode.entries.size)   // 3
}

Sealed classes and interfaces

An enum constant cannot carry different data for each case. A sealed class (or sealed interface) is a closed family of types: all its subtypes are known to the compiler, and each can hold its own data. Combined with when, the compiler checks that you handled every case, so you do not need else.

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

fun render(state: UiState): String = when (state) {
    UiState.Loading -> "Showing spinner"
    is UiState.Success -> "Showing ${state.items.size} items"
    is UiState.Error -> "Error: ${state.message}"
}   // no else needed: the compiler knows all cases

If someone later adds a new state, such as Empty, every when that forgot it stops compiling. That is a big safety win in large apps.

object and companion object

object declares a class and its single instance at the same time: a singleton. Use it for things there should be only one of, like app-wide constants. A companion object lives inside a class and holds members that belong to the class itself rather than to each object, similar to static members in Java; it is often used for factory functions and constants.

object AppConfig {
    const val BASE_URL = "https://api.example.com/"
    const val TIMEOUT_SECONDS = 30
}

class User private constructor(val phone: String) {
    companion object {
        fun fromInput(raw: String): User? {
            val digits = raw.filter { it.isDigit() }.takeLast(10)
            return if (digits.length == 10) User(digits) else null
        }
    }
}

fun main() {
    println(AppConfig.BASE_URL)
    println(User.fromInput("+91 98765 43210")?.phone)   // 9876543210
}

Common mistakes

• Using an enum for states that need different data (Error with a message). Use a sealed interface.
• Adding else to a when over a sealed type: it hides missing cases. Leave it out so the compiler can help.
• Putting var properties in data classes used as UI state. Prefer val and copy.
• Using object for things that should have many instances.