¿Cuáles son las características de trabajar con…

La clase enum es un tipo especial de clase utilizada para representar un conjunto de constantes.

Características:

Definición de constantes: Cada constante de la enumeración es una instancia de la clase de enumeración.
```
enum class Color {
    RED, GREEN, BLUE
}
```

Propiedades y métodos: Las clases enum pueden tener propiedades y métodos. Cada constante puede implementarlos de manera diferente.

enum class Status(val description: String) {
    SUCCESS("Operación exitosa"),
    ERROR("Ocurrió un error"),
    PENDING("En espera")
}

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

    fun getOpposite(): Direction {
        return when (this) {
            NORTH -> SOUTH
            SOUTH -> NORTH
            EAST -> WEST
            WEST -> EAST
        }
    }
}

Clases anónimas: Cada constante de la enumeración puede declararse con una clase anónima que proporcione sus propias implementaciones de métodos o propiedades.

enum class State {
    IDLE {
        override fun signal() = READY
    },
    READY {
        override fun signal() = IDLE
    }; // La punto y coma es obligatorio antes de declarar miembros de la clase

    abstract fun signal(): State
}

Implementación de interfaces: La clase enum puede implementar interfaces.

interface Printable {
    fun printName()
}

enum class Shape : Printable {
    CIRCLE {
        override fun printName() {
            println("Círculo")
        }
    },
    SQUARE {
        override fun printName() {
            println("Cuadrado")
        }
    }
}

Propiedades incorporadas: Cada constante tiene propiedades incorporadas name (nombre de la constante como cadena) y ordinal (posición de la constante en la declaración, comenzando desde 0).
```
enum class Priority {
    LOW, MEDIUM, HIGH
}

fun main() {
    println(Priority.MEDIUM.name)    // Salida: MEDIUM
    println(Priority.HIGH.ordinal) // Salida: 2
}
```

Funciones incorporadas:

enumValues<T>(): Devuelve un Array de todas las constantes en la clase enum.
enumValueOf<T>(name: String): Devuelve la constante de la clase enum con el nombre dado. Lanza IllegalArgumentException si no se encuentra la constante.

fun main() {
    val allPriorities = enumValues<Priority>()
    println(allPriorities.joinToString()) // Salida: LOW, MEDIUM, HIGH

    val highPriority = enumValueOf<Priority>("HIGH")
    println(highPriority) // Salida: HIGH
}

Uso en expresiones when: Son ideales para usarse en when. El compilador advertirá si no todas las ramas están cubiertas (al usarse como expresión con valor de retorno).

fun processStatus(status: Status) {
    when (status) {
        Status.SUCCESS -> println("Éxito")
        Status.ERROR -> println("Error")
        Status.PENDING -> println("En espera")
    }
}

Las enums en Kotlin son más potentes en comparación con sus análogos en Java, permitiendo agregar propiedades, métodos y implementar interfaces.

¿Cuáles son las características de trabajar con clases Enum en Kotlin?