Kotlin - Enum Classes

Kotlin Enum Classes 

Introduction to Enum Classes in Kotlin

Kotlin Enum Classes are one of the most powerful and commonly used features of the Kotlin programming language. They are used to represent a fixed set of constants in a type-safe and readable way. Enum classes improve code clarity, maintainability, and safety by restricting values to predefined constants. In modern Kotlin development, enum classes are widely used in Android development, backend services, game development, and enterprise applications.

In this detailed tutorial, you will learn everything about Kotlin Enum Classes, including syntax, properties, functions, constructors, interfaces, sealed alternatives, best practices, performance considerations, and real-world use cases. This guide is designed for beginners as well as experienced developers who want a deep understanding of Kotlin enums.

What is an Enum Class in Kotlin?

An Enum Class in Kotlin is a special type of class that is used to define a group of constants. Each constant is an object of the enum class. Unlike traditional constants, enum values are strongly typed and can contain properties, methods, and even implement interfaces.

Enum classes are especially useful when you want to represent a limited set of options such as days of the week, directions, states, roles, statuses, or modes of operation.

Key Characteristics of Enum Classes

• Enum constants are singleton objects.
• Each enum constant is an instance of the enum class.
• Enum classes can have properties and methods.
• Enum classes can implement interfaces.
• Enum classes cannot extend other classes.

Basic Syntax of Kotlin Enum Class

The syntax of an enum class in Kotlin is simple and intuitive. You define an enum class using the enum keyword followed by the class name and enum constants.

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

In this example, Direction is an enum class, and NORTH, SOUTH, EAST, and WEST are enum constants. Each constant is an instance of the Direction enum class.

Using Enum Values in Kotlin

Enum values can be accessed using the class name followed by the constant name. They can also be used in when expressions, comparisons, and collections.

fun printDirection(direction: Direction) {
    when (direction) {
        Direction.NORTH -> println("Moving North")
        Direction.SOUTH -> println("Moving South")
        Direction.EAST -> println("Moving East")
        Direction.WEST -> println("Moving West")
    }
}

Using enum classes with when expressions ensures compile-time safety. If you forget to handle any enum constant, the compiler will warn you.

Enum Classes with Properties

One of the powerful features of Kotlin enum classes is that each enum constant can have properties. This allows you to associate additional data with each constant.

enum class Status(val code: Int, val description: String) {
    SUCCESS(200, "Operation Successful"),
    ERROR(500, "Internal Server Error"),
    NOT_FOUND(404, "Resource Not Found")
}

In this example, each enum constant has two properties: code and description. These properties can be accessed just like normal class properties.

val status = Status.SUCCESS
println(status.code)
println(status.description)

Enum Classes with Methods

Enum classes can also contain methods. These methods can be common for all constants or overridden individually.

enum class Operation {
    ADD {
        override fun apply(a: Int, b: Int): Int = a + b
    },
    SUBTRACT {
        override fun apply(a: Int, b: Int): Int = a - b
    };

    abstract fun apply(a: Int, b: Int): Int
}

In this example, each enum constant provides its own implementation of the apply method. This pattern is useful when each constant has unique behavior.

Enum Classes and Constructors

Enum classes can have primary constructors, but they cannot have secondary constructors. The constructor parameters are used to initialize properties of enum constants.

enum class Planet(val mass: Double, val radius: Double) {
    EARTH(5.97, 6371.0),
    MARS(0.642, 3389.5),
    JUPITER(1898.0, 69911.0)
}

Each enum constant passes values to the constructor. This makes enum classes ideal for representing real-world entities with fixed attributes.

Enum Classes and Interfaces

Although enum classes cannot inherit from other classes, they can implement interfaces. This allows you to enforce a contract on enum constants.

interface Printable {
    fun print()
}

enum class Color : Printable {
    RED {
        override fun print() {
            println("Color is Red")
        }
    },
    GREEN {
        override fun print() {
            println("Color is Green")
        }
    },
    BLUE {
        override fun print() {
            println("Color is Blue")
        }
    }
}

This approach is useful when enum constants need to provide specific implementations of interface methods.

Enum Class Built-in Properties and Functions

Kotlin provides several built-in properties and functions for enum classes that make them easy to work with.

name and ordinal

Each enum constant has a name and ordinal property. The name represents the constant name, and ordinal represents its position.

val day = Direction.NORTH
println(day.name)
println(day.ordinal)

Note: Avoid relying heavily on ordinal values because changing the order of constants can break logic.

values and valueOf

The values function returns an array of all enum constants. The valueOf function converts a string to an enum constant.

for (dir in Direction.values()) {
    println(dir)
}

val selected = Direction.valueOf("EAST")
println(selected)

Enum Classes with when Expression

Enum classes are commonly used with when expressions. This ensures that all possible cases are handled explicitly.

fun getMessage(status: Status): String {
    return when (status) {
        Status.SUCCESS -> "Everything went well"
        Status.ERROR -> "Something went wrong"
        Status.NOT_FOUND -> "Data not found"
    }
}

The compiler enforces exhaustiveness, which improves code safety and readability.

Enum vs Sealed Classes in Kotlin

Enum classes and sealed classes are often compared in Kotlin. While both are used to represent restricted hierarchies, they serve different purposes.

• Enum classes are best for a fixed set of constants.
• Sealed classes are better for complex state hierarchies.
• Enum constants are predefined and finite.
• Sealed classes allow subclasses with different data.

Choose enum classes when the values are simple and well-defined. Choose sealed classes when behavior and data vary significantly.

Using Enum Classes

• Use enum classes for fixed and known sets of values.
• Avoid using ordinal values in business logic.
• Prefer properties over complex conditional logic.
• Use meaningful names for enum constants.
• Consider sealed classes for advanced use cases.

Performance Considerations

Enum classes are efficient and lightweight. Each enum constant is instantiated once and reused. However, excessive use of complex logic inside enum constants can affect readability.

In performance-critical applications, avoid frequent conversions using valueOf and prefer direct references.

 Use Cases of Enum Classes

Enum classes are widely used in real-world Kotlin applications. Common use cases include:

• User roles such as ADMIN, USER, and GUEST
• Application states like LOADING, SUCCESS, ERROR
• Network response statuses
• Game character states
• Configuration modes and themes

Kotlin Enum Classes provide a robust and elegant way to represent fixed sets of values. With support for properties, methods, interfaces, and constructors, they go far beyond simple constants. Understanding enum classes is essential for writing clean, maintainable, and type-safe Kotlin code.By mastering Kotlin Enum Classes, you can improve your application design, reduce errors, and write more expressive code that aligns with modern Kotlin best practices.