Trabalhando com Enums em Kotlin

Trabalhando com Enums em Kotlin

1. Visão geral

Neste tutorial, vamos nos aprofundar nos enums do Kotlin.

Com a evolução das linguagens de programação, o uso e a aplicação de enums também avançaram.

Enum constants today aren’t just mere collections of constants - eles podem ter propriedades, implementar interfaces e muito mais.

Para iniciantes em Kotlin, confira este artigo sobre noções básicas de Kotlin -Introduction to the Kotlin Language.

2. Enums básicos de Kotlin

Vamos dar uma olhada no básico das enums no Kotlin.

2.1. Definindo Enums

Vamos definir uma enumeração como tendo três constantes que descrevem os tipos de cartão de crédito:

enum class CardType {
    SILVER, GOLD, PLATINUM
}

2.2. Inicializando constantes Enum

Enums in Kotlin, just like in Java, can have a constructor. Como constantes enum são instâncias de uma classeEnum, as constantes podem ser inicializadas passando valores específicos para o construtor.

Vamos especificar os valores de cor para vários tipos de cartão:

enum class CardType(val color: String) {
    SILVER("gray"),
    GOLD("yellow"),
    PLATINUM("black")
}

Podemos acessar o valor da cor de um tipo de cartão específico com:

val color = CardType.SILVER.color

3. Constantes Enum como classes anônimas

Podemos definir um comportamento constante de enum específico, criando-os como classes anônimas. As constantes então precisam substituir as funções abstratas definidas na definiçãoEnum.

Por exemplo, para cada tipo de cartão, podemos ter diferentes cálculos de reembolso.

Vamos ver como podemos implementá-lo:

enum class CardType {
    SILVER {
        override fun calculateCashbackPercent() = 0.25f
    },
    GOLD {
        override fun calculateCashbackPercent() = 0.5f
    },
    PLATINUM {
        override fun calculateCashbackPercent() = 0.75f
    };

    abstract fun calculateCashbackPercent(): Float
}

Podemos invocar os métodos substituídos das classes constantes anônimas com:

val cashbackPercent = CardType.SILVER.calculateCashbackPercent()

4. Enums Implementando Interfaces

Digamos que haja uma interfaceICardLimit que define os limites de vários tipos de cartão:

interface ICardLimit {
    fun getCreditLimit(): Int
}

Agora, vamos ver como nosso enum pode implementar essa interface:

enum class CardType : ICardLimit {
    SILVER {
        override fun getCreditLimit() = 100000
    },
    GOLD {
        override fun getCreditLimit() = 200000
    },
    PLATINUM {
        override fun getCreditLimit() = 300000
    }
}

Para acessar o limite de crédito de um tipo de cartão, podemos usar a mesma abordagem do exemplo anterior:

val creditLimit = CardType.PLATINUM.getCreditLimit()

5. Construções Enum Comuns

5.1. Obtendo constantes Enum por nome

Para obter uma constante enum por seu nomeString, usamos a função estáticavalueOf():

val cardType = CardType.valueOf(name.toUpperCase())

5.2. Iterando por meio de constantes Enum

Para iterar por todas as constantes enum, usamos a função estáticavalues():

for (cardType in CardType.values()) {
    println(cardType.color)
}

5.3. Métodos estáticos

Para adicionar uma função “estática” a um enum, podemos usar umcompanion object:

companion object {
    fun getCardTypeByName(name: String) = valueOf(name.toUpperCase())
}

Agora podemos chamar esta função com:

val cardType = CardType.getCardTypeByName("SILVER")

Observe que Kotlin não tem um conceito de métodosstatic. O que mostramos aqui é uma maneira de obter a mesma funcionalidade do Java, mas usando os recursos do Kotlin.

6. Conclusão

Este artigo apresenta uma introdução às enumerações no idioma Kotlin e seus principais recursos.

Introduzimos alguns conceitos simples, como definir enums e inicializar as constantes. Também mostramos alguns recursos avançados, como a definição de constantes enum como classes anônimas e interfaces de implementação de enums.

A implementação de todos esses exemplos e trechos de código pode ser encontrada emthe GitHub project. Como é um projeto do Maven, deve ser fácil importar e executar como está.