In Kotlin, enums are used to represent a fixed set of constant values. They are similar to enums in other programming languages like Java. To define an enum in Kotlin, use the "enum class" keyword followed by the name of the enum.
Here's an example of defining an enum for days of the week:
1 2 3 4 5 6 7 8 9 |
enum class DayOfWeek { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY } |
In this example, we defined an enum called "DayOfWeek" with seven possible values: MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, and SUNDAY.
To use an enum value, simply reference it by its name, like this:
1
|
val day = DayOfWeek.MONDAY
|
Enums can have properties and functions like normal classes. Here's an example of adding a property to our "DayOfWeek" enum:
1 2 3 4 5 6 7 8 9 |
enum class DayOfWeek(val isWeekend: Boolean) { MONDAY(false), TUESDAY(false), WEDNESDAY(false), THURSDAY(false), FRIDAY(false), SATURDAY(true), SUNDAY(true) } |
In this modified enum, we added a property called "isWeekend" which tells whether a particular day is a weekend or not.
To access the properties or call functions associated with an enum value, use the dot notation:
1 2 |
val day = DayOfWeek.SATURDAY println(day.isWeekend) // Output: true |
Enums can also be used in when expressions to perform pattern matching. Here's an example:
1 2 3 4 5 6 |
fun getDayType(day: DayOfWeek): String { return when (day) { DayOfWeek.SATURDAY, DayOfWeek.SUNDAY -> "Weekend" else -> "Weekday" } } |
In this example, the function "getDayType" takes a "DayOfWeek" enum value as an argument and returns a string indicating whether it's a weekend or a weekday.
Enums in Kotlin provide a convenient and type-safe way to define and work with a fixed set of values, making your code more readable and less error-prone.
Best Kotlin Books to Read in 2024
How to use enums in Kotlin?
To use enums in Kotlin, you can follow these steps:
- Define an enum class: Use the enum keyword followed by the class name and the list of enum constants enclosed in curly braces.
1 2 3 |
enum class Direction { NORTH, SOUTH, EAST, WEST } |
- Access enum constants: You can access enum constants by their name using the dot notation.
1
|
val direction = Direction.NORTH
|
- Use enum constants in conditional statements: You can use enum constants in conditional statements like when expressions.
1 2 3 4 5 6 |
when (direction) { Direction.NORTH -> println("The direction is north.") Direction.SOUTH -> println("The direction is south.") Direction.EAST -> println("The direction is east.") Direction.WEST -> println("The direction is west.") } |
- Use enum properties and methods: Enums can have properties and methods like regular classes. You can define properties and methods inside the enum class body.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
enum class Direction { NORTH, SOUTH, EAST, WEST; val opposite: Direction get() = when (this) { NORTH -> SOUTH SOUTH -> NORTH EAST -> WEST WEST -> EAST } fun isHorizontal(): Boolean { return this == EAST || this == WEST } } val direction = Direction.NORTH val oppositeDirection = direction.opposite // Returns Direction.SOUTH println(direction.isHorizontal()) // Prints false |
In this example, the opposite property returns the opposite direction, and the isHorizontal() method checks if the direction is horizontal.
These are the basic steps to use enums in Kotlin. Enums provide a way to represent a fixed set of values and make the code more readable and maintainable.
What are sealed classes in relation to enums?
Sealed classes are classes that cannot be inherited or extended by other classes. They are used to restrict the inheritance hierarchy and ensure no other classes can derive from it.
In relation to enums, a sealed class can be used instead of an enum when a finite set of values is needed. Enums in some programming languages provide a fixed set of predefined values, but they cannot be extended or used as a base class. On the other hand, a sealed class can define a set of predefined values and allow for further extension, providing more flexibility in comparison to enums.
By using a sealed class instead of an enum, you can create a hierarchy of classes that represents related values, and each subclass can have its own properties, methods, and behavior. This allows more complex operations based on the specific values represented by these classes, rather than just relying on simple constants provided by enums.
How to convert an enum to a string in Kotlin?
In Kotlin, you can convert an enum to a string by using the name property of the enum value. Here's an example:
1 2 3 4 5 6 7 8 9 10 11 |
enum class Color { RED, GREEN, BLUE } fun main() { val color = Color.RED val colorString = color.name println(colorString) // Output: "RED" } |
In this example, we have an enum Color with three values: RED, GREEN, and BLUE. We can convert a specific color, such as Color.RED, to a string using the name property. The name property returns the name of the enum value as a string.
Note that the name property returns the name of the enum value exactly as it is defined in the enum, so it is case-sensitive.
How to check if a value exists in an enum in Kotlin?
In Kotlin, you can check if a value exists in an enum by using the enumValues<T>() function and the contains() method. Here's an example:
1 2 3 4 5 6 7 8 9 10 11 12 13 |
enum class Color { RED, GREEN, BLUE } fun main() { val color = Color.RED if (enumValues<Color>().contains(color)) { println("$color exists in the Color enum.") } else { println("$color does not exist in the Color enum.") } } |
In this example, the enumValues<Color>() function returns an array of all the enum values. The contains() method is then used to check if the color variable exists in the enum.
