Le classi Enum suscitano un sacco di polemiche nel mondo Android per una serie di ragioni, ma dimostrano ancora di essere usate dagli sviluppatori esperti giorno dopo giorno. Perché è così?
(Attenzione: mentre la sintassi del codice qui sarà in Kotlin, tutte le informazioni sono valide anche per le classi enum di Java)
Cos’è una classe Enum?
In poche parole, un Enum è un tipo di classe speciale che contiene una lista di costanti. L’uso più comune è quello di rappresentare diversi tipi di un particolare oggetto, o quando una variabile può essere solo uno di un certo insieme di valori.
enum class Direction { NORTH, SOUTH, EAST, WEST}
Le costanti di un enum non richiedono necessariamente un valore. Senza un valore, possono essere usate nella validazione attraverso if e switch.
val directionToTreasure = Direction.NORTHwhen(directionToTreasure) { Direction.NORTH -> indicateNorth() Direction.SOUTH -> indicateSouth() Direction.EAST -> indicateEast() Direction.WEST -> indicateWest()}
Probabilmente non è il modo migliore per gestire queste funzioni di indicazione, ma avete capito l’idea. Almeno sarà molto divertente
Il loro uso può comunque essere espanso per includere valori attaccati ad ogni costante.
enum class Color(val rgb: Int) { RED(0xFF0000) GREEN(0x00FF00) BLUE(0x0000FF)}
Quando usate le classi enum in questo modo, potete ottenere il loro valore in questo modo:
val shirtColour = Color.BLUEval color: Int = shirtColour.rgb
Che altro può fare un Enum?
Per dirla in breve, un sacco di cose
In primo luogo, invece delle costanti, gli enum possono essere implementati come classi anonime con i propri metodi e sovrascrivere i metodi base.
enum class ProtocolState yadayada {}
Possono anche implementare interfacce in modo simile
enum class IntArithmetics yadayada {}
Infine, enum ha due costanti che ti forniscono alcuni valori piuttosto utili.
val name: String // The name of the constantval ordinal: Int // The position of the constant in the list of valuesif (shirtColour.name == "BLUE") { // Do some blue stuff}
In effetti, grazie all’uso di queste costanti, puoi anche mappare comodamente tra i tipi enum e String/Int.
Enum -> Int
yourEnum.ordinal
Int -> Enum
EnumType.values()
Stringa -> Enum
EnumType.valueOf(yourString)
Enum -> String
yourEnum.name
Crediti a questo ragazzo su StackOverflow per aver condiviso questa mappatura
Qual è lo scopo delle classi Enum?
Ho capito, non è la cosa più semplice, ma vi aggiornerò.
Per la maggior parte, le classi enum sono usate per produrre codice più leggibile. Quando avete un oggetto che può avere più tipi diversi, è molto più conciso identificarli con un valore leggibile piuttosto che con un intero arbitrario.
// Bad codewhen(direction) { 0 -> goNorth() 1 -> goSouth() 2 -> goEast() 3 -> goWest()}// Good codewhen(direction) { Direction.NORTH -> goNorth() Direction.SOUTH -> goSouth() Direction.EAST -> goEast() Direction.WEST -> goWest()}
Un altro scopo utile degli enum è quando avete dati che arrivano come una stringa ma avete bisogno di mapparli in un valore int, come quando la vostra API dà il tipo del vostro oggetto ma avete bisogno di passarlo in un adattatore RecyclerView che richiede un Int per i tipi View. Personalmente ho usato questo metodo nella mia classe enum per farlo accadere.
@JvmStaticfun getType(type: String): BlockType? = when(type) { "hero" -> ContentHero "products" -> ContentProductList else -> null }
Perché non dovresti usare le classi Enum
Scommetto che ora stai pensando “Aspetta un secondo. Mi hai detto tutto su come usare gli Enum e ora mi dici di non usarli?”. Ascoltami, amico.
In parole povere, gli Enum sono costosi, amico! So che i telefoni cellulari stanno migliorando di giorno in giorno, ma per uno, ci sono ancora troppe persone là fuori con telefoni meno potenti e due, il modo in cui creiamo le applicazioni e le librerie che usiamo stanno usando anche più memoria.
Questa è una vecchia notizia. Gli Enum sarebbero un problema di memoria per i telefoni che funzionano con Dalvik, ma questo è stato praticamente abbandonato al posto di ART (Android Runtime Machine). Aggiunto al fatto che anche le persone nei paesi più poveri hanno telefoni abbastanza potenti, e che Proguard può ora ottimizzare il codice meglio che mai, si può dire che gli Enum non causano più un problema di prestazioni.
Ci sono ancora alcune alternative che si possono usare che possono ottenere risultati simili ad una classe Enum.
Costanti
Anche le costanti sono super concise. Tengono un singolo valore e gli danno un nome. Sono anche estremamente leggere.
*Def
L’annotazione *Def è anche ottima se avete una variabile che accetta solo certi valori.
@IntDef({RED, GREEN, BLUE})
Perché scegliere ancora gli Enum rispetto a queste alternative?
L’enum brilla molto di più dei suoi fratelli funzionali è l’esaustività. Quando si usa con Kotlin, si può usare un’istruzione switch come questa
val foo = when(someEnum) {}
E quando lo si fa, si è costretti a gestire un caso per ogni costante nel proprio enum, altrimenti il codice non verrà compilato. Con le costanti e le annotazioni *def, il meglio che si ottiene sono avvertimenti lint. Gli enum portano semplicemente a un codice più sicuro.
(Crediti a u/-manabreak da Reddit per questo)
Quindi, finché il vostro uso degli enum porta a un codice più conciso per la vostra applicazione e specialmente nel caso di Kotlin, una migliore sicurezza dei casi, enumerate pure a vostro piacimento.