In Kotlin, enums are used to represent a fixed number of constant values. They provide a way to define a collection of related constants and are commonly used to define a set of options or states.
To create an enum in Kotlin, you start with the enum keyword followed by the name of the enum. Inside the body of the enum, you define each constant value as a separate entry.
1 2 3 4 5 6 |
enum class Direction { NORTH, SOUTH, EAST, WEST } |
Here, an enum called Direction is created with four constant values: NORTH, SOUTH, EAST, and WEST. Each enum value is defined using a comma-separated list, and conventionally written in uppercase.
Enums can also have properties and functions associated with them. For example:
1 2 3 4 5 6 7 8 9 10 |
enum class Planet(val mass: Double, val radius: Double) { EARTH(5.972e24, 6_371.0), MARS(6.39e23, 3_389.5), MOON(7.342e22, 1_737.1); fun calculateSurfaceGravity(): Double { val G = 6.67300e-11 return G * mass / (radius * radius) } } |
In this example, the enum Planet has additional properties mass and radius associated with each constant value. It also has a function calculateSurfaceGravity() which can be invoked on each enum instance.
To use an enum, you can either refer to one of its constants by name or obtain an array of all the enum values. For example:
1 2 3 4 5 |
val direction: Direction = Direction.NORTH println(direction) // Output: NORTH val allDirections: Array<Direction> = Direction.values() println(allDirections.joinToString()) // Output: NORTH, SOUTH, EAST, WEST |
In Kotlin, enums are considered as first-class citizens and can be used widely as a more powerful replacement for Java enums. They can have their own properties, methods, and implement interfaces, making them quite flexible.
Best Kotlin Books to Read in 2024
What happens when you convert an enum constant to a string in Kotlin?
When you convert an enum constant to a string in Kotlin, the name of the enum constant is returned as a string.
Let's say you have an enum class called Color, and it has constants RED, GREEN, and BLUE. When you convert the enum constant RED to a string, it will return the string "RED". Similarly, GREEN and BLUE will return "GREEN" and "BLUE" respectively.
Here's an example:
1 2 3 4 5 6 7 8 9 |
enum class Color { RED, GREEN, BLUE } fun main() { val color: Color = Color.RED val colorString: String = color.toString() println(colorString) // Output: RED } |
In the example above, the toString() method is implicitly called when you assign the enum constant Color.RED to a string variable colorString. This converts the enum constant to a string representation with the name "RED".
What is the default value of an enum constant in Kotlin?
In Kotlin, the default value of an enum constant is the name of the constant itself.
How to use enum constants as properties in Kotlin classes?
To use enum constants as properties in Kotlin classes, you can follow these steps:
Step 1: Declare an enum class:
1 2 3 |
enum class Color { RED, GREEN, BLUE } |
Step 2: Create a class and define a property of the enum type:
1 2 3 |
class Car(val color: Color) { // Other properties and methods } |
Step 3: Create an instance of the class and pass an enum constant as an argument:
1
|
val car = Car(Color.GREEN)
|
Now, you can access the enum constant property of the class instance just like any other property:
1
|
println("The color of the car is ${car.color}")
|
This will output:
1
|
The color of the car is GREEN
|
You can also use the enum constant in when statements or as parameters in functions. For example:
1 2 3 4 5 6 7 |
fun printCarInfo(car: Car) { when (car.color) { Color.RED -> println("The car is red") Color.GREEN -> println("The car is green") Color.BLUE -> println("The car is blue") } } |
Now, if you call the printCarInfo function with a Car instance, it will print the corresponding color information.
How to add methods to enum classes in Kotlin?
In Kotlin, you can add methods to enum classes by using the enum keyword combined with a class declaration.
Here's an example:
1 2 3 4 5 6 7 |
enum class Color { RED, ORANGE, YELLOW, GREEN, BLUE, INDIGO, VIOLET; fun printColorName() { println(name.toLowerCase().capitalize()) // Example method implementation } } |
In the example above, we have defined an enum class named Color containing a list of colors. After the enum values (RED, ORANGE, etc.), you can define additional methods like printColorName().
To use the added method, you can call it on any instance of the enum class:
1 2 |
val color = Color.RED color.printColorName() // Output: Red |
Note that enum classes in Kotlin are powerful and can have properties, custom constructors, and more, similar to regular classes.
What is the significance of the valueOf() function in Kotlin enums?
The valueOf() function in Kotlin enums is used to obtain an enum constant from its string representation. It is a predefined function that is automatically added to all enum classes in Kotlin.
The significance of the valueOf() function is that it provides a convenient way to convert a string into an enum constant, enabling developers to parse or deserialize enum values from external sources or user inputs.
For example, consider an enum called Color with constant values RED, GREEN, and BLUE. By using the valueOf() function, you can easily obtain the enum constant based on a given string, like Color.valueOf("RED").
However, it's important to note that the valueOf() function is case-sensitive and will throw an IllegalArgumentException if the string does not match any of the enum constant names. Thus, it's recommended to handle such exceptions when using the valueOf() function.
How to use enum constructors with parameters in Kotlin?
In Kotlin, you can use enum constructors with parameters by adding the parameters directly in the enum declaration. Here's an example:
1 2 3 4 5 |
enum class Color(val rgb: Int) { RED(0xFF0000), GREEN(0x00FF00), BLUE(0x0000FF) } |
In this example, the Color enum has a parameter rgb of type Int. Each enum constant (RED, GREEN, BLUE) is created with a specific rgb value.
You can access the parameter value for each enum constant using the dot notation, like Color.RED.rgb.
Here's how you can use enum constructors with parameters:
1 2 3 4 |
fun main() { val redColor = Color.RED println("RGB value of Red color: ${redColor.rgb}") } |
Output:
1
|
RGB value of Red color: 16711680
|
In this example, we create an instance redColor of the Color enum and access its rgb value using the dot notation.
Note that enum constants can have additional properties, methods, and implementations just like regular classes.
