Introduction: In Kotlin, sealed classes and sealed interfaces are powerful tools for defining restricted hierarchies of types. In Android development, understanding when to use each can greatly enhance the structure and maintainability of your code. Let’s dive into practical examples to help you make informed decisions

Sealed Class: Managing State in Android UI

Use Case: Representing a closed hierarchy of states, such as UI states or network request states.

Practical Implementation:

sealed class ViewState {
    object Loading : ViewState()
    data class Success(val data: List<Item>) : ViewState()
    data class Error(val message: String) : ViewState()
}

// Usage example:
fun renderState(viewState: ViewState) {
    when (viewState) {
        is ViewState.Loading -> showLoading()
        is ViewState.Success -> showData(viewState.data)
        is ViewState.Error -> showError(viewState.message)
    }
}

When to Choose: Use sealed classes when you have a fixed set of related states or types that require exhaustive handling, such as UI states or network request states.

Sealed Interface: Defining Behavior Across Unrelated Types

Use Case: Defining a closed set of types that implement certain behavior.

Practical Implementation:

sealed interface Loggable {
    fun log()
}

class FileLogger : Loggable {
    override fun log() {
        // Implementation for file logging
    }
}

class DatabaseLogger : Loggable {
    override fun log() {
        // Implementation for database logging
    }
}

// Usage example:
fun logAll(loggables: List<Loggable>) {
    loggables.forEach { it.log() }
}

When to Choose: Use sealed interfaces when you want to define a closed set of types that share common behavior but are otherwise unrelated, such as different types of loggers.

Conclusion: In Android development, choosing between sealed classes and sealed interfaces depends on the specific requirements of your project. Sealed classes are ideal for managing state in UI components, while sealed interfaces are useful for defining shared behavior across unrelated types. By understanding their practical implementations, you can make informed decisions to enhance the structure and maintainability of your Android codebase.

Share your experiences with sealed classes and interfaces in Android development!

About the author: Muhammad Mohsan is a seasoned Android developer with a decade of expertise in crafting innovative Android applications. He is deeply passionate about building robust Android apps and has a rich portfolio of projects. Connect with him on GitHub or LinkedIn to explore his work further.

This article is previously published on proandroiddev.com