As classes Enum suscitam muita controvérsia no mundo Android por uma série de razões, mas elas ainda provam ser usadas por desenvolvedores experientes dia após dia. Por que isso é assim?
(Atenção: enquanto a sintaxe do código aqui vai estar em Kotlin, todas as informações aqui se aplicam às classes de enumeração Java também)
O que é uma classe Enum?
Simplesmente colocado, um Enum é um tipo de classe especial que contém uma lista de constantes. O uso mais comum é representar diferentes tipos de um objeto em particular, ou quando uma variável pode ser apenas um de um determinado conjunto de valores.
enum class Direction { NORTH, SOUTH, EAST, WEST}
As constantes de um enum não requerem necessariamente um valor. Sem um valor, elas podem ser usadas na validação através de instruções ifs e switch.
val directionToTreasure = Direction.NORTHwhen(directionToTreasure) { Direction.NORTH -> indicateNorth() Direction.SOUTH -> indicateSouth() Direction.EAST -> indicateEast() Direction.WEST -> indicateWest()}
Provavelmente não é a melhor maneira de lidar com estas indicações de funções, mas você tem a idéia. Pelo menos será muito divertido
O seu uso pode no entanto ser expandido para incluir valores anexados a cada constante.
enum class Color(val rgb: Int) { RED(0xFF0000) GREEN(0x00FF00) BLUE(0x0000FF)}
Quando você usa classes Enum desta maneira, você pode obter o seu valor assim:
val shirtColour = Color.BLUEval color: Int = shirtColour.rgb
O que mais um Enum pode fazer?
Para colocar em poucas palavras, uma porra de um lote
Primeiro, ao invés de constantes, enumera classes anónimas com os seus próprios métodos e métodos base de overriding.
enum class ProtocolState yadayada {}
Tambem podem implementar interfaces de forma semelhante
enum class IntArithmetics yadayada {}
Finalmente, enum tem duas constantes que lhe fornecem alguns valores bastante úteis.
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}
Na verdade, graças ao uso dessas constantes, você também pode mapear convenientemente entre enum e os tipos String/Int.
Enum -> Int
yourEnum.ordinal
Int -> Enum
EnumType.values()
String -> Enum
EnumType.valueOf(yourString)
Enum -> String
yourEnum.name
Créditos para este tipo no StackOverflow para compartilhar este mapeamento
Qual é o propósito das classes Enum?
Eu te pego, não é a coisa mais simples, mas vou te preencher.
Para a maior parte, classes de enumeração são usadas para produzir código mais legível. Quando você tem um objeto que pode ter vários tipos diferentes, é muito mais conciso identificá-los com um valor legível do que algum inteiro arbitrário.
// 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()}
Outro propósito útil dos Enums é quando você tem dados que vêm como uma string mas você precisa eventualmente mapeá-los para um valor int, como quando sua API dá o tipo do seu objeto mas você precisa passá-lo para um Adaptador RecyclerView que requer um Int para os tipos View. Eu pessoalmente usei este método na minha classe enum para fazer isso acontecer.
@JvmStaticfun getType(type: String): BlockType? = when(type) { "hero" -> ContentHero "products" -> ContentProductList else -> null }
Por que você não deve usar classes Enum
Aposto agora que você está pensando “Espere um segundo. Disseste-me tudo sobre como usar o Enums e agora vais dizer-me para não os usar?”. Ouve-me companheiro.
Simplesmente dito, os Enums são companheiros caros! Eu sei que os celulares estão melhorando a cada dia, mas para começar, ainda há muita gente lá fora com celulares menos poderosos e dois, a maneira como fazemos aplicativos e as bibliotecas que usamos estão usando mais memória também.
Esta é uma velha notícia. Enums seria um problema de memória para telefones rodando com Dalvik, mas isso basicamente foi descontinuado no lugar do ART (Android Runtime Machine). Além do fato de que mesmo pessoas em países mais pobres têm telefones bastante poderosos, e que o Proguard pode agora otimizar o código melhor do que nunca, é seguro dizer que os Enums não causam mais problemas de desempenho.
Ainda há algumas alternativas que você pode usar que podem alcançar resultados similares a uma classe Enum.
Constants
Constants são super concisas também. Possuem um único valor e dão-lhe um nome. Também são extremamente leves.
*Def
A anotação *Def também é óptima se tiver uma variável que só aceita certos valores.
@IntDef({RED, GREEN, BLUE})
Porquê escolher ainda Enums sobre estas alternativas?
Onde o enum brilha muito mais do que os seus irmãos funcionais é a exaustividade. Quando usado com o Kotlin, você pode usar uma declaração de troca como esta
val foo = when(someEnum) {}
E quando o faz, você é forçado a lidar com um caso para cada constante do seu enumero, caso contrário, o seu código não será compilado. Com constantes e *def anotações, o melhor que você recebe são avisos de cotão. Enums simplesmente levam a um código mais seguro.
(Credits to u/-manabreak from Reddit for this)
Então, desde que seu uso de enumeração leve a um código mais conciso para sua aplicação e especialmente no caso do Kotlin, melhor segurança da caixa, por todos os meios, enumere de acordo com o seu coração.