Um recurso útil durante a programação é ter a capacidade de indicar que uma variável tem apenas um conjunto finito de valores possíveis. Para fazer isso, a maioria das linguagens de programação introduziu o conceito de enumerações.
Embora as enumerações geralmente representem apenas uma mera lista nomeada de valores constantes predefinidos, os enums do Kotlin são muito mais do que isso. Na verdade, eles são classes reais, e não tipos simples ou dados estruturados limitados.
Isso se traduz no fato de que eles podem ter propriedades e métodos personalizados, implementar interfaces, usar classes anônimas e muito mais. Portanto, as classes de enum do Kotlin desempenham um papel crucial na linguagem.
Além disso, o emprego de enums torna seu código mais legível e menos sujeito a erros. É por isso que todo desenvolvedor Kotlin deve saber como usá-los. Então, vamos mergulhar nas classes enum e ver tudo que você precisa aprender para dominá-las.
Classes enum Kotlin vs. tipos enum Java
Em Java , enums são tipos. Especificamente, a documentação oficial define um tipo de enum como “um tipo de dados especial que permite um variável para ser um conjunto de constantes predefinidas. ” Isso significa que a referida variável deve ser igual a um dos valores predefinidos. Esses valores são constantes e representam as propriedades do tipo enum.
Apesar de ser um tipo, a declaração enum Java na verdade cria uma classe nos bastidores. Portanto, enums Java podem incluir métodos e propriedades personalizados. Este, além dos padrões adicionados automaticamente pelo compilador. É isso-nada mais pode ser feito com os tipos de enum do Java.
Ao contrário do que acontece em Java, enums do Kotlin são aulas nativamente, e não apenas nos bastidores. É por isso que eles são chamados de classes enum, em oposição aos tipos de enum Java. Isso evita que os desenvolvedores os considerem meros conjuntos de constantes, como pode acontecer em Java.
Como veremos, os enums do Kotlin são muito mais do que isso. Eles não apenas podem usar classes anônimas, mas também implementar interfaces, como qualquer outra classe Kotlin. Portanto, vamos esquecer os tipos de enum Java e começar a mergulhar nas classes de enum do Kotlin.
Recursos básicos dos enums do Kotlin
Vamos começar a explorar os recursos mais comuns oferecidos pelos enums do Kotlin.
Definindo enums
O caso de uso mais básico para as classes de enum do Kotlin é tratá-las como coleções de constantes. Nesse caso, eles são chamados de enums de tipo seguro e podem ser definidos da seguinte forma:
enum class Day {SEGUNDA, TERÇA, QUARTA, QUINTA, SEXTA, SÁBADO, DOMINGO}
Como você pode ver, o enum palavra-chave é seguida pela palavra-chave class. Isso deve evitar que você seja enganado e pense que enums do Kotlin são meros tipos.
Em seguida, vem o nome da classe enum. Finalmente, dentro do corpo da classe enum, as opções possíveis separadas por vírgula chamadas constantes de enum. Observe que, como são constantes, seus nomes devem estar sempre em letras maiúsculas. É nisso que consiste a classe mais simples de enum do Kotlin.
Inicializando enums
Os enums do Kotlin são classes, o que significa que podem ter um ou mais construtores. Portanto, você pode inicializar constantes enum passando os valores necessários para um dos construtores válidos. Isso é possível porque as constantes enum nada mais são do que instâncias da própria classe enum.
Vamos ver como isso funciona por meio de um exemplo:
enum class Day (val dayOfWeek: Int) {SEGUNDA-FEIRA (1), TERÇA-FEIRA (2), QUARTA (3), QUINTA (4), SEXTA-FEIRA (5), SÁBADO (6), DOMINGO (7)}
Dessa forma, cada constante enum está associada ao número relativo do dia da semana.
Normalmente, a abordagem baseada no construtor é usada para fornecer constantes enum com informações úteis ou valores significativos. Um dos casos mais comuns é fornecer a eles uma propriedade printableName personalizada. Isso é muito útil ao imprimi-los e pode ser feito da seguinte maneira:
enum class Day (val printableName: String) {SEGUNDA-FEIRA (“SEGUNDA”), TERÇA-FEIRA (“TERÇA”), QUARTA-FEIRA (“QUARTA”), THURSDAY (“Thursday”), FRIDAY (“Friday”), SATURDAY (“Saturday”), SUNDAY (“Sunday”)}
Propriedades integradas
As classes Kotlin enum vêm com algumas propriedades integradas. Assim como o que acontece em Java, eles são adicionados automaticamente a cada classe enum pelo compilador. Portanto, você pode acessá-los em qualquer instância de classe enum. Vamos ver todos eles:
ordinal
ordinal permite que você recupere onde a constante enum atual aparece na lista. É um índice baseado em zero, o que significa que a primeira constante na lista de opções tem valor 0, a segunda 1 e assim por diante. Ao implementar a interface Comparable, esta propriedade será usada na lógica de classificação. nome
nome retorna o nome da constante enum como um fragmento.
Vamos ver esses dois em ação por meio do seguinte exemplo:
enum class Day (val dayOfWeek: Int) {SEGUNDA (1), TERÇA (2), QUARTA (3), QUINTA (4), SEXTA ( 5), SÁBADO (6), DOMINGO (7)} diversão main () {for (dia em DAY.values ()) println (“[$ {day.ordinal}]-> $ {day.name} ($ { day.dayOfWeek} ^ dia da semana)”)}
Executando este código, você obteria o seguinte resultado:
[0]-> SEGUNDA-FEIRA (1 ^ dia da semana) [1]-> TERÇA-FEIRA (2 ^ dia da semana) [2]-> QUARTA (3 ^ dia da semana) [3]-> QUINTA-FEIRA (4 ^ dia da semana) [4]-> SEXTA-FEIRA (5 ^ dia da semana) semana) [5]-> SÁBADO (6 ^ dia da semana) [6]-> DOMINGO (7 ^ dia da semana)
Como você pode ver, a string retornada pelo nome de propriedade embutida coincide com a constante em si. Isso não os torna muito imprimíveis e é por isso que adicionar uma propriedade printableName personalizada pode ser útil.
Além disso, este exemplo destaca por que adicionar um índice personalizado também pode ser necessário. Isso ocorre porque o ordinal é um índice baseado em zero que deve ser usado durante a programação, em vez de fornecer conteúdo informativo.
Recursos avançados de enums do Kotlin
Agora, é hora de se aprofundar os recursos mais avançados e complicados oferecidos pelas classes Kotlin enum.
Adicionando propriedades e métodos personalizados
Propriedades e métodos personalizados podem ser adicionados às classes enum, assim como em qualquer outra classe Kotlin. O que muda é a sintaxe, que deve seguir regras específicas.
Em particular, métodos e propriedades devem ser adicionados abaixo da definição de constantes enum, após um ponto e vírgula. Assim como qualquer outra propriedade em Kotlin, você pode fornecer a eles um valor padrão. Além disso, as classes enum podem ter métodos estáticos e de instância:
enum class Day {SEGUNDA-FEIRA (1,”SEGUNDA”), TERÇA-FEIRA (2,”TERÇA”), QUARTA-FEIRA (3,”QUARTA”), QUINTA-FEIRA (4 ,”Quinta-feira”), SEXTA-FEIRA (5,”Sexta-feira”), SÁBADO (6,”Sábado”), DOMINGO (7,”Domingo”);//fim das constantes//propriedades personalizadas com valores padrão var dayOfWeek: Int?=null var printableName: String?=construtor nulo ()//construtor de construtores personalizados (dayOfWeek: Int, printableName: String) {this.dayOfWeek=dayOfWeek this.printableName=printableName}//método personalizado divertido customToString (): String {return”[$ {dayOfWeek}]-> $ printableName”}}
Neste exemplo, um construtor personalizado, duas propriedades personalizadas e um método de instância personalizado foram adicionados à classe enum. Propriedades e métodos podem ser acessados por meio de instâncias, que são constantes enum, com a seguinte sintaxe:
//acessando a propriedade dayOfWeek Day.MONDAY.dayOfWeek//acessando o método customToString () Day.MONDAY.customToString ()
Lembre-se de que Kotlin não tem o conceito de métodos estáticos. No entanto, o mesmo resultado pode ser alcançado aproveitando objetos complementares , que são suportados por classes Kotlin enum. Métodos definidos dentro de objetos companheiros não dependem de instâncias específicas e podem ser acessados estaticamente. Você pode adicionar um da seguinte maneira:
enum class Day {SEGUNDA, TERÇA, QUARTA, QUINTA, SEXTA, SÁBADO, DOMINGO; objeto companheiro {fun getNumberOfDays ()=values (). size}}
Agora, você pode acessar o método getNumberOfDays () desta forma:
Day.getNumberOfDays ()
Como você pode ver, o método é chamado estaticamente na classe e não depende de nenhuma instância. Observe que o método estático sintético values () foi usado durante a implementação. Você verá o que é e como usá-lo em breve.
Usando classes anônimas para definir constantes enum
Podemos criar classes anônimas para definir constantes enum específicas. Em contraste com Java, as classes enum do Kotlin suportam classes anônimas.
Em particular, constantes enum podem ser instanciadas por classes anônimas. Eles apenas precisam fornecer uma implementação para os métodos abstratos da própria classe enum. Isso pode ser conseguido com a seguinte sintaxe:
enum class Day {SEGUNDA-FEIRA {override fun nextDay ()=TUESDAY}, TUESDAY {override fun nextDay ()=WEDNESDAY}, WEDNESDAY {override fun nextDay ()=THURSDAY}, QUINTA-FEIRA {substituir diversão nextDay ()=SEXTA}, SEXTA-FEIRA {substituir diversão nextDay ()=SÁBADO}, SÁBADO {substituir diversão nextDay ()=DOMINGO}, DOMINGO {substituir diversão nextDay ()=SEGUNDA-FEIRA}; abstract fun nextDay (): Day}
Conforme mostrado aqui, cada constante enum é instanciada declarando suas próprias classes anônimas enquanto sobrescreve o método abstrato necessário. Isso é exatamente como aconteceria em qualquer outra classe Kotlin anônima.
Enums podem implementar interfaces
Embora as classes Kotlin enum não possam derivar de uma classe, classe enum ou uma classe abstrata, eles podem realmente implementar uma ou mais interfaces.
Nesse caso, cada constante de enum deve fornecer uma implementação de métodos de interface. Isso pode ser alcançado com uma implementação comum, como segue:
interface IDay {fun firstDay (): Day} enum class Day: IDay {SEGUNDA-FEIRA, TERÇA-FEIRA, QUARTA-FEIRA, QUINTA-FEIRA, SEXTA-FEIRA, SÁBADO, DOMINGO; override fun firstDay (): Day {return MONDAY}}
Ou usando classes anônimas como mostrado antes:
interface IDay {fun nextDay (): Day} enum class Day: IDay {SEGUNDA {override fun nextDay ( )=TERÇA-FEIRA}, TERÇA-FEIRA {substituir diversão nextDay ()=QUARTA-FEIRA}, QUARTA-FEIRA {substituir diversão nextDay ()=QUINTA-FEIRA}, QUINTA-FEIRA {substituir diversão nextDay ()=SEXTA}, SEXTA-FEIRA {ignorar diversão nextDay ()=QUINTA-FEIRA}, QUINTA-FEIRA {substituir diversão nextDay ()=SEXTA}, SEXTA-FEIRA {substituir diversão nextDay ()=SÁBADO}, {substituir diversão nextDay ()=DOMINGO}, DOMINGO {substituir diversão nextDay ()=SEGUNDA-FEIRA}; }
Em ambos os casos, cada constante de enum tem o método de interface IDay implementado.
Enums em ação
Agora que você viu os recursos básicos e avançados, tem tudo o que é necessário para começar a usar as classes enum do Kotlin. Vamos vê-los em ação por meio dos três casos de uso mais comuns.
Enums e quando
As classes Enum são particularmente úteis quando usadas com when declaração condicional. Isso ocorre porque as expressões when devem levar em consideração cada condição possível. Em outras palavras, eles devem ser exaustivos.
Como os enums oferecem um conjunto limitado de valores por definição, o Kotlin pode usar isso para descobrir se todas as condições foram consideradas. Caso contrário, um erro em tempo de compilação será gerado. Vamos ver enums em ação com a expressão when:
enum class Day {SEGUNDA, TERÇA, QUARTA, SEXTA, SÁBADO, DOMINGO} fun main (currentDay: Day) {when (currentDay) {Day.MONDAY-> trabalho () Day.TUESDAY-> work () Day.WEDNESDAY-> work () Day.THURSDAY-> work () Day.FRIDAY-> work () Day.SATURDAY-> descanso () Day.S DOMINGO-> descanso ( )}} fun work () {println (“Working”)} fun rest () {println (“Resting”)}
Conforme mostrado, os enums permitem diferenciar a lógica com base em seu valor. Eles também tornam seu código mais legível e menos sujeito a erros. Isso porque estabelecem o número máximo de opções possíveis a serem consideradas em um demonstrativo when. Dessa forma, você não pode esquecer um.
Métodos sintéticos Enums e Kotlin
Semelhante às propriedades integradas mencionadas anteriormente, cada classe enum também possui métodos sintéticos. Eles são adicionados automaticamente pelo Kotlin no momento da compilação e representam funções utilitárias que podem ser acessadas estaticamente. Vamos ver os mais importantes e como usá-los:
values ()
Ele retorna a lista de todas as constantes enum contidas na classe enum. valueOf (value: String)
Retorna a constante enum cuja propriedade name corresponde à string de valor passada como parâmetro. Se não for encontrado, uma IllegalArgumentException é lançada.
Vamos vê-los em ação por meio de um exemplo:
enum class Day (val printableName: String) {MONDAY (“Monday”), TUESDAY (“Tuesday”), WEDNESDAY (“Wednesday”), THURSDAY (“Quinta-feira”), SEXTA-FEIRA (“Sexta-feira”), SÁBADO (“Sábado”), DOMINGO (“Domingo”)} fun main () {for (day in Day.values ()) println (day.printableName) println (Day. valueOf (“MONDAY”). printableName)}
Quando executado, o seguinte resultado seria impresso:
Segunda Terça Quarta Quinta Sexta Sábado Domingo Segunda-feira
Observe que o mesmo resultado pode ser obtido usando os dois seguintes funções globais do Kotlin: enumValues
Iterando por meio de enums
Finalmente, ambos os casos de uso podem ser combinados para iterar através deles graças ao método sintético values () e executar ações diferentes com base em seu valor com uma expressão when. Vejamos um exemplo baseado nesta abordagem:
enum class Day (val printableName: String) {MONDAY (“Monday”), TUESDAY (“Tuesday”), WEDNESDAY (“Wednesday”), THURSDAY (“Thursday”), FRIDAY (“Friday”), SATURDAY (“Saturday”), SUNDAY (“Sunday”)} fun main () {for (day in Day.values ()) {//comportamento comum println (day.printableName)//ação executada com base no valor do dia quando (dia) {Day.MONDAY-> work () Day.TUESDAY-> work () Day.WEDNESDAY-> work () Day.THURSDAY-> work () Day.FRIDAY-> work () Day.SATURDAY-> rest () Day.SUNDAY-> rest ()}//comportamento comum println (“—“)}} fun work () {println (“Working”)} fun rest () { println (“Resting”)}
Dessa forma, a lógica personalizada pode ser executada com base em cada um dos valores possíveis atuais dos quais a classe enum consiste. Se lançado, o snippet retornaria:
Segunda-feira trabalhando—terça-feira trabalhando—quarta-feira trabalhando—quinta-feira trabalhando—sexta-feira trabalhando—sábado descansando—domingo descansando—
Conclusão
Neste artigo, vimos o que são as classes enum do Kotlin, quando e como usá-las e por quê. Conforme mostrado, os enums do Kotlin vêm com muitos recursos e oferecem possibilidades infinitas. Portanto, simplesmente pensar neles como um conjunto de constantes seria um erro, ao contrário do que acontece em muitas outras linguagens de programação.
Como os enums do Kotlin são classes, eles podem ter suas próprias propriedades, métodos e implementar interfaces. Além disso, quando usados corretamente, eles podem tornar seu código mais claro, mais legível e menos sujeito a erros. É por isso que todo desenvolvedor Kotlin deve usá-los, e ensinar tudo o que é necessário para fazer isso corretamente é o assunto deste artigo.
Obrigado por ler! Espero que você tenha achado este artigo útil. Sinta-se à vontade para entrar em contato comigo se tiver perguntas, comentários ou sugestões.
