Quali sono le caratteristiche del lavoro con le…

La classe enum è un tipo speciale di classe usato per rappresentare un insieme di costanti.

Caratteristiche:

Definizione delle costanti: Ogni costante dell'enumerazione è un'istanza della classe enum.
```
enum class Color {
    RED, GREEN, BLUE
}
```

Proprietà e metodi: Le classi enum possono avere proprietà e metodi. Ogni costante può implementarli in modo diverso.

enum class Status(val description: String) {
    SUCCESS("Operazione riuscita"),
    ERROR("Si è verificato un errore"),
    PENDING("In attesa")
}

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

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

Classi anonime: Ogni costante enum può essere dichiarata con una classe anonima che fornisce le proprie implementazioni di metodi o proprietà.

enum class State {
    IDLE {
        override fun signal() = READY
    },
    READY {
        override fun signal() = IDLE
    }; // Il punto e virgola è obbligatorio prima di dichiarare i membri della classe

    abstract fun signal(): State
}

Implementazione di interfacce: La classe enum può implementare interfacce.

interface Printable {
    fun printName()
}

enum class Shape : Printable {
    CIRCLE {
        override fun printName() {
            println("Cerchio")
        }
    },
    SQUARE {
        override fun printName() {
            println("Quadrato")
        }
    }
}

Proprietà incorporate: Ogni costante ha proprietà incorporate name (nome della costante come stringa) e ordinal (posizione della costante nella dichiarazione, a partire da 0).

enum class Priority {
    LOW, MEDIUM, HIGH
}

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

Funzioni incorporate:
- enumValues<T>(): Restituisce un array di tutte le costanti della classe enum.
- enumValueOf<T>(name: String): Restituisce la costante della classe enum con il nome specificato. Lancia IllegalArgumentException se la costante non viene trovata.
```
fun main() {
    val allPriorities = enumValues<Priority>()
    println(allPriorities.joinToString()) // Output: LOW, MEDIUM, HIGH

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

Utilizzo in espressioni when: Ideale per l'uso in when. Il compilatore avviserà se tutte le ramificazioni non sono coperte (quando usato come espressione con valore di ritorno).

fun processStatus(status: Status) {
    when (status) {
        Status.SUCCESS -> println("Successo")
        Status.ERROR -> println("Errore")
        Status.PENDING -> println("In attesa")
    }
}

Le enum in Kotlin sono più potenti rispetto alle loro controparti in Java, consentendo di aggiungere proprietà, metodi e di implementare interfacce.

Quali sono le caratteristiche del lavoro con le classi Enum in Kotlin?