Kotlin enum Keyword
last modified April 19, 2025
Kotlin's enum classes provide a powerful way to define a set of related constants.
The enum keyword creates type-safe enumerations with properties and
methods. This tutorial explores enum classes in depth with practical examples.
Basic Definitions
The enum keyword in Kotlin declares an enumeration class. Enum
classes restrict variables to have only predefined values. They can have
properties, methods, and implement interfaces while remaining type-safe.
Basic Enum Declaration
The simplest enum class contains just a list of constants. Each constant is an instance of the enum class. Enums provide type safety over using plain constants.
package com.zetcode
enum class Direction {
NORTH, SOUTH, EAST, WEST
}
fun main() {
val dir = Direction.NORTH
when (dir) {
Direction.NORTH -> println("Going North")
Direction.SOUTH -> println("Going South")
Direction.EAST -> println("Going East")
Direction.WEST -> println("Going West")
}
}
Here we define a simple Direction enum with four constants. In main(), we assign NORTH to a variable and use when expression to handle each case. The compiler ensures we handle all possible enum values.
Enum with Properties
Enum constants can have properties. Each constant must provide values for these properties when declared. Properties make enums more expressive and useful.
package com.zetcode
enum class Color(val rgb: Int) {
RED(0xFF0000),
GREEN(0x00FF00),
BLUE(0x0000FF)
}
fun main() {
val color = Color.RED
println("RGB value of ${color.name}: ${color.rgb}")
}
This enum class Color has a property rgb that stores the hexadecimal color value. Each constant provides its specific rgb value. We access both the enum name and its property in the main function.
Enum with Methods
Enum classes can define methods that all constants inherit. Each constant can also override these methods to provide specific behavior. This makes enums powerful.
package com.zetcode
enum class Operation {
ADD {
override fun apply(x: Int, y: Int) = x + y
},
SUBTRACT {
override fun apply(x: Int, y: Int) = x - y
},
MULTIPLY {
override fun apply(x: Int, y: Int) = x * y
};
abstract fun apply(x: Int, y: Int): Int
}
fun main() {
val op = Operation.ADD
println("5 + 3 = ${op.apply(5, 3)}")
}
Here we define an Operation enum with an abstract method apply(). Each constant implements this method differently. The main function demonstrates using the ADD operation to perform addition.
Enum Implementing Interfaces
Enum classes can implement interfaces. Each constant can then provide its own implementation of interface methods. This allows polymorphic behavior with enums.
package com.zetcode
interface Printer {
fun print()
}
enum class MessageType : Printer {
INFO {
override fun print() {
println("Information message")
}
},
WARNING {
override fun print() {
println("Warning message")
}
};
}
fun main() {
val msg = MessageType.WARNING
msg.print()
}
The MessageType enum implements the Printer interface. Each constant provides its own implementation of the print() method. In main(), we call print() on the WARNING constant, demonstrating polymorphic behavior.
Enum with Custom Constructors
Enum classes can have constructors to initialize constants with specific values. Each constant must pass arguments to the constructor when declared. This enables rich enum definitions.
package com.zetcode
enum class Planet(val mass: Double, val radius: Double) {
MERCURY(3.303e+23, 2.4397e6),
VENUS(4.869e+24, 6.0518e6),
EARTH(5.976e+24, 6.37814e6);
val surfaceGravity: Double
get() = 6.67300E-11 * mass / (radius * radius)
}
fun main() {
val earth = Planet.EARTH
println("Earth surface gravity: ${earth.surfaceGravity}")
}
The Planet enum has a constructor that takes mass and radius parameters. Each constant provides these values. The enum also has a computed property surfaceGravity that uses these values to calculate gravity.
Iterating Over Enum Values
Kotlin provides the values function to get all constants of an
enum class. This allows iteration over all possible values of an enumeration.
package com.zetcode
enum class Season {
SPRING, SUMMER, AUTUMN, WINTER
}
fun main() {
for (season in Season.values()) {
println(season)
}
}
This example demonstrates how to iterate over all values of the Season enum using the values() function. The for loop prints each season constant to the console.
Using Enum with When Expression
Enums work particularly well with Kotlin's when expression. The compiler can verify if all enum cases are covered, making when expressions with enums exhaustive.
package com.zetcode
enum class TrafficLight {
RED, YELLOW, GREEN
}
fun getMessage(light: TrafficLight): String {
return when (light) {
TrafficLight.RED -> "Stop"
TrafficLight.YELLOW -> "Caution"
TrafficLight.GREEN -> "Go"
}
}
fun main() {
println(getMessage(TrafficLight.RED))
}
The getMessage function uses a when expression to return different messages based on the TrafficLight enum value. The compiler ensures all enum cases are handled. The main function demonstrates calling this function with RED light.
Best Practices for Enum Usage
- Use for fixed sets: Enums are ideal for representing fixed sets of related constants.
- Leverage properties: Add properties to enums to make them more expressive and useful.
- Consider methods: Define methods in enums when constants need behavior.
- Implement interfaces: Use interfaces to add capabilities to enums polymorphically.
- Prefer when expressions: Use when with enums for exhaustive pattern matching.
Source
Kotlin Enum Classes Documentation
This tutorial covered Kotlin's enum keyword in depth, showing basic
declarations through advanced usage. We explored properties, methods, interfaces,
and practical examples. Enums provide type safety and organization for fixed sets
of related constants.
Author
List all Kotlin tutorials.