Kotlin Data, Enum & Sealed Classes — data class, object, companion

1Data Classes

A data class is a class designed to hold data. Kotlin auto-generates equals(), hashCode(), toString(), copy(), and componentN() functions — eliminating boilerplate POJO code common in Java.

Basic data classdata class User(val id: Int, val name: String, val email: String)

fun main() {
    val user1 = User(1, "Nikhil", "nikhil@mail.com")
    val user2 = User(1, "Nikhil", "nikhil@mail.com")

    println(user1)              // User(id=1, name=Nikhil, email=nikhil@mail.com)
    println(user1 == user2)     // true — structural equality
}

copy() — immutable updates

copy functionfun main() {
    val user = User(1, "Nikhil", "old@mail.com")
    val updated = user.copy(email = "new@mail.com")

    println(user.email)    // old@mail.com — original unchanged
    println(updated.email) // new@mail.com
}

Destructuring declarations

componentN destructuringfun main() {
    val user = User(1, "Alex", "alex@mail.com")
    val (id, name, email) = user

    println("$id: $name <$email>")
}

Data class rules

Rule	Details
Primary constructor	Must have at least one `val` or `var` parameter
Cannot be	abstract, open, sealed, or inner
Generated	equals, hashCode, toString, copy, component1..N
Use for	DTOs, API models, Room entities, UI state payloads

Android / Retrofit

Data classes are the standard for JSON parsing with Gson, Moshi, or kotlinx.serialization — field names map directly to JSON keys.

2Enum Classes

An enum class defines a fixed set of constants. Each constant is an object instance of the enum class. Enums can have properties, methods, and implement interfaces.

Simple enumenum class Direction {
    NORTH, SOUTH, EAST, WEST
}

fun main() {
    val dir = Direction.NORTH
    println(dir.name)    // NORTH
    println(dir.ordinal) // 0
}

Enum with properties and methods

Enum with constructorenum class Status(val label: String, val code: Int) {
    ACTIVE("Active", 1),
    INACTIVE("Inactive", 0),
    PENDING("Pending", 2);

    fun isActive() = this == ACTIVE
}

fun main() {
    val status = Status.ACTIVE
    println("${status.label} (${status.code})")  // Active (1)
    println(status.isActive())                   // true
}

Iterating enum entries

entries property (Kotlin 1.9+)fun main() {
    for (direction in Direction.entries) {
        println(direction)
    }

    val fromString = Direction.valueOf("EAST")
    println(fromString)  // EAST
}

Enum vs sealed class

Feature	enum class	sealed class
Instances	Fixed singleton constants	Multiple instances per subtype allowed
Data per case	Same properties for all (optional)	Different data per subclass
Best for	Days, directions, order status	UI state, network result, AST nodes

when exhaustiveness: Both enums and sealed classes enable exhaustive when expressions — the compiler warns if you miss a case.

3Sealed Classes

A sealed class restricts which classes can inherit from it. All direct subclasses must be declared in the same file (or nested). This enables exhaustive when checks — ideal for representing restricted state hierarchies.

Sealed class for UI statesealed class UiState {
    data object Loading : UiState()
    data class Success(val data: List<String>) : UiState()
    data class Error(val message: String) : UiState()
}

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

fun main() {
    render(UiState.Success(listOf("A", "B")))
}

Sealed class vs enum

Sealed — different data per subtypesealed class Result<out T> {
    data class Ok<T>(val value: T) : Result<T>()
    data class Fail(val error: Throwable) : Result<Nothing>()
}

fun handle(result: Result<Int>) {
    when (result) {
        is Result.Ok -> println("Value: ${result.value}")
        is Result.Fail -> println("Failed: ${result.error.message}")
    }
}

Sealed interface (Kotlin 1.5+)

sealed interfacesealed interface PaymentMethod
data class CreditCard(val number: String) : PaymentMethod
data object Cash : PaymentMethod
data class UPI(val id: String) : PaymentMethod

Use case	Example sealed hierarchy
ViewModel UI state	Loading / Success / Error
Navigation events	GoToHome / GoToDetail(id) / Back
Parse results	Valid(data) / Invalid(reason)
Expression trees	Number / Add / Subtract nodes

data object

Use data object Loading for singleton sealed subclasses with no data — cleaner than object Loading with proper toString().

4Object Declaration

An object declaration creates a singleton — a class with exactly one instance, initialized lazily when first accessed. Use it for shared utilities, caches, or app-wide managers.

Singleton objectobject AppConfig {
    const val APP_NAME = "LearnHub"
    var debugMode = false

    fun log(message: String) {
        if (debugMode) println("[DEBUG] $message")
    }
}

fun main() {
    AppConfig.debugMode = true
    AppConfig.log("App started")
    println(AppConfig.APP_NAME)
}

Object vs class instance

Declaration	Instances	Access
`class User`	Many — each `User()` is new	`User()`
`object Database`	Exactly one (singleton)	`Database.connect()`
`data object Idle`	One sealed subclass instance	`UiState.Idle`

Object expression (anonymous object)

Create an unnamed object inline — useful for one-off implementations:

Anonymous objectinterface ClickListener {
    fun onClick()
}

fun createListener(): ClickListener {
    return object : ClickListener {
        override fun onClick() {
            println("Anonymous click handler")
        }
    }
}

fun main() {
    createListener().onClick()
}

Implementing interfaces with object

object implementing interfaceinterface Logger {
    fun log(msg: String)
}

object ConsoleLogger : Logger {
    override fun log(msg: String) = println("[LOG] $msg")
}

fun main() {
    ConsoleLogger.log("Ready")
}

Thread safety: Kotlin initializes object lazily on first access in a thread-safe way — suitable for shared app singletons when dependency injection is not used.

5Companion Objects

A companion object is an object tied to a class — similar to Java's static members but implemented as a real singleton object. Access members with the class name: MyClass.create().

Factory with companion objectclass User private constructor(val name: String) {
    companion object {
        const val MAX_NAME_LENGTH = 50

        fun create(name: String): User {
            require(name.length <= MAX_NAME_LENGTH)
            return User(name)
        }

        fun createGuest() = User("Guest")
    }
}

fun main() {
    val user = User.create("Nikhil")
    val guest = User.createGuest()
    println("${user.name}, ${guest.name}")
}

Companion object with name

Named companionclass MyClass {
    companion object Factory {
        fun create(): MyClass = MyClass()
    }
}

fun main() {
    val obj = MyClass.create()
    val same = MyClass.Factory.create()
}

Companion implementing interface

Companion as factory interfaceinterface Factory<T> {
    fun create(): T
}

class MyService private constructor() {
    companion object : Factory<MyService> {
        override fun create(): MyService = MyService()
    }
}

fun main() {
    val service = MyService.create()
}

Companion object vs object declaration

Feature	companion object	object declaration
Belongs to	A class (one per class)	Standalone — no enclosing class
Access	`ClassName.member`	`ObjectName.member`
Java static equivalent	Yes (@JvmStatic for methods)	Singleton class
Typical use	Factory methods, constants	App-wide singletons

@JvmStatic for Java interop

@JvmStaticclass Utils {
    companion object {
        @JvmStatic
        fun formatDate(): String = "2026-05-29"
    }
}
// Java: Utils.formatDate();
// Without @JvmStatic: Utils.Companion.formatDate();

Android Fragment pattern

Fragments often use companion object { fun newInstance(args): MyFragment } — a factory that sets arguments before showing the fragment. See also Objects in OOP.

6Summary Cheatsheet

Topic	Key Takeaway
Data Classes	`data class`; auto equals/hashCode/toString/copy/destructuring
Enum Classes	Fixed constants; properties, methods, `entries`
Sealed Classes	Restricted hierarchy; exhaustive `when`; UI state / Result types
Object Declaration	`object Name { }` — thread-safe singleton
Companion Objects	`companion object` — factory, constants, @JvmStatic
Choose enum vs sealed	enum = fixed set; sealed = varying data per subtype
Next lesson	Collections — List, Set, Map

Data, Enum & Sealed Classes MCQ Practice

10 Basic MCQs 10 Advanced MCQs

10 Basic Data, Enum & Sealed Classes MCQs

1

data class auto-generates?

AOnly toString

Bequals, hashCode, copy, toString, componentN

CConstructors only

DNothing

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is A.

2

enum class is declared with?

Aenum Color

Benum class Color

Csealed Color

Ddata enum

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is A.

3

sealed class restricts?

AAll inheritance globally

BSubclasses to same file/module

COnly enums

DInterfaces only

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is B.

4

object creates?

AMany instances

BSingle singleton instance

CAbstract type

DCopy of class

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is A.

5

companion object lives?

AOutside class

BInside class as singleton

CIn interface only

DTop-level only

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is B.

6

copy() on data class?

ADeletes object

BCreates copy with optional changed fields

COnly for enums

DThrows error

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is A.

7

enum can have?

AOnly names

BProperties and methods per constant

CNo constructors

DOnly abstract methods

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is B.

8

sealed class with when?

ANever exhaustive

BCompiler checks all branches exhaustive

COnly for Int

DReplaces if only

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is A.

9

data class requires?

ANo primary constructor params

BPrimary constructor with val/var params

CMust extend open class

DJava only

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is B.

10

object expression creates?

ANamed singleton only

BAnonymous object instance

CEnum entry

DSealed subclass auto

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is A.

10 Advanced Data, Enum & Sealed Classes MCQs

11

enum values() returns?

AArray of all enum constants

BFirst constant only

CMap

DSet of strings

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is B.

12

component1() in data class?

AFirst property for destructuring

BCopy method

CHash code

DCompanion access

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is A.

13

sealed vs enum?

ASame thing

BSealed for rich typed hierarchy; enum for fixed named constants

CEnum always better

DSealed only for Int

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is B.

14

companion object can?

AImplement interfaces and have name

BOnly hold primitives

CReplace primary ctor

DBe inherited

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is A.

15

enum ordinal is?

ARandom id

BZero-based position in declaration order

CHash code

DString name

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is B.

16

Anonymous object syntax?

Aobject : Interface { override fun f() {} }

Bnew Object()

Cclass anonymous

Dlambda only

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is A.

17

data class copy named arg?

Auser.copy(name = "New")

Buser.clone(name)

CcopyUser()

DNot supported

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is B.

18

sealed interface added for?

AReplacing classes

BRestricted interface implementations with exhaustive when

CJava interop only

DGenerics only

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is A.

19

Each enum constant is?

AA singleton object instance

BA primitive int only

CA sealed subclass always

DMutable global

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is A.

20

object vs companion?

ASame

Bobject is standalone singleton; companion is singleton inside class

Ccompanion is top-level

Dobject is abstract

Explanation: See Data, Enum & Sealed Classes lesson — correct answer is A.

Click an option to select, then check answers.

Data, Enum & Sealed Classes Interview Q&A

15 topic-focused questions for interviews and revision.

1What is a data class?easy

Answer: class declared with data keyword — compiler generates equals, hashCode, toString, copy, and component functions for primary constructor properties.

2What is an enum class?easy

Answer: Fixed set of named constants: enum class Direction { NORTH, SOUTH, EAST, WEST } — each constant is an object.

3What is a sealed class?easy

Answer: Restricted class hierarchy — subclasses known at compile time; enables exhaustive when expressions.

4What is an object declaration?easy

Answer: Singleton — object Database { fun connect() } — one instance for the whole program.

5When use data class vs regular class?medium

Answer: Data class for holding data/DTOs/models. Regular class when you need complex inheritance or no generated methods.

6Explain copy() on data classes.medium

Answer: user.copy(age = 31) creates new instance with changed fields; useful for immutable updates especially in UI state.

7What is a companion object?medium

Answer: Singleton inside a class — factory methods, constants, alternative constructors; called as ClassName.method().

8sealed class vs enum?medium

Answer: Enum: flat named constants. Sealed: hierarchy of types with different data per subclass — e.g. Result.Success vs Result.Error.

9Destructuring declarations?medium

Answer: val (name, age) = user — uses component1(), component2() generated by data class.

10Can enums have methods?medium

Answer: Yes — each constant can override methods; enum can have properties, init block, and abstract methods per constant.

11Why sealed classes for UI/network state?hard

Answer: Exhaustive when forces handling all states; compiler error if you add subclass and miss branch — safer than string constants.

12object expression vs object declaration?hard

Answer: Declaration: single named singleton. Expression: anonymous object implementing interface on the fly — one-off instance.

13data class restrictions?hard

Answer: Primary constructor params must be val/var; cannot be open, abstract, inner, or sealed; at least one param typical.

14companion object and @JvmStatic?hard

Answer: @JvmStatic on companion members exposes true static methods to Java callers.

15sealed class subclass location rules?hard

Answer: Direct subclasses must be in same package (Kotlin 1.5+ module/file rules apply) — compiler knows full set for exhaustive checks.

Data, Enum & Sealed Classes

Table of Contents

1Data Classes

copy() — immutable updates

Destructuring declarations

Data class rules

2Enum Classes

Enum with properties and methods

Iterating enum entries

Enum vs sealed class

3Sealed Classes

Sealed class vs enum

Sealed interface (Kotlin 1.5+)

4Object Declaration

Object vs class instance

Object expression (anonymous object)

Implementing interfaces with object

5Companion Objects

Companion object with name

Companion implementing interface

Companion object vs object declaration

@JvmStatic for Java interop

6Summary Cheatsheet

Data, Enum & Sealed Classes MCQ Practice

10 Basic Data, Enum & Sealed Classes MCQs

data class auto-generates?

enum class is declared with?

sealed class restricts?

object creates?

companion object lives?

copy() on data class?

enum can have?

sealed class with when?

data class requires?

object expression creates?

10 Advanced Data, Enum & Sealed Classes MCQs

enum values() returns?

component1() in data class?

sealed vs enum?

companion object can?

enum ordinal is?

Anonymous object syntax?

data class copy named arg?

sealed interface added for?

Each enum constant is?

object vs companion?

Data, Enum & Sealed Classes Interview Q&A