Arbejde med Enums i Kotlin

1. Oversigt

I denne vejledning dykker vi dybt ned i Kotlin-enums.

Med udviklingen af ​​programmeringssprog er brugen og anvendelsen af ​​enums også avanceret.

Enum-konstanter i dag er ikke kun samlinger af konstanter - de kan have egenskaber, implementere grænseflader og meget mere.

For begyndere fra Kotlin, se denne artikel om Kotlin-basics - Introduktion til Kotlin-sproget.

2. Grundlæggende Kotlin Enums

Lad os se på det grundlæggende i enums i Kotlin.

2.1. Definition af Enums

Lad os definere et enum som tre konstanter, der beskriver kreditkorttyper:

enum klasse CardType {SILVER, GOLD, PLATINUM}

2.2. Initialisering af Enum-konstanter

Enums i Kotlin, ligesom i Java, kan have en konstruktør. Da enum-konstanter er forekomster af en Enum klasse, kan konstanterne initialiseres ved at overføre specifikke værdier til konstruktøren.

Lad os specificere farveværdier til forskellige korttyper:

enum klasse CardType (valfarve: streng) {SILVER ("grå"), GULD ("gul"), PLATINUM ("sort")}

Vi kan få adgang til farveværdien af ​​en bestemt korttype med:

val farve = CardType.SILVER.color

3. Enum-konstanter som anonyme klasser

Vi kan definere specifik enum konstant adfærd ved at oprette dem som anonyme klasser. Konstanter skal derefter tilsidesætte de abstrakte funktioner, der er defineret i Enum definition.

For hver korttype kan vi f.eks. Have forskellige cash-back-beregninger.

Lad os se, hvordan vi kan implementere det:

enum klasse CardType {SILVER {tilsidesætte sjov beregneCashbackPercent () = 0.25f}, GULD {tilsidesætte sjov beregneCashbackPercent () = 0.5f}, PLATINUM {tilsidesætte sjov beregneCashbackPercent () = 0.75f}; abstrakt sjov beregneCashbackPercent (): Float}

Vi kan påkalde de tilsidesatte metoder til de anonyme konstante klasser med:

val cashbackPercent = CardType.SILVER.calculateCashbackPercent ()

4. Enums implementering af grænseflader

Lad os sige, at der er en ICardLimit interface, der definerer kortgrænserne for forskellige korttyper:

interface ICardLimit {fun getCreditLimit (): Int}

Lad os nu se, hvordan vores enum kan implementere denne grænseflade:

enum klasse CardType: ICardLimit {SILVER {tilsidesætte sjov getCreditLimit () = 100000}, GULD {tilsidesætte sjov getCreditLimit () = 200000}, PLATINUM {tilsidesætte sjov getCreditLimit () = 300000}}

For at få adgang til kreditgrænsen for en korttype kan vi bruge den samme tilgang som i det foregående eksempel:

val creditLimit = CardType.PLATINUM.getCreditLimit ()

5. Fælles Enum-konstruktioner

5.1. Få Enum-konstanter ved navn

At få en enum konstant ved sin Snor navn, vi bruger Værdi af() statisk funktion:

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

5.2. Iterering gennem Enum-konstanter

For at gentage alle enum-konstanter bruger vi værdier () statisk funktion:

for (cardType i CardType.values ​​()) {println (cardType.color)}

5.3. Statiske metoder

For at tilføje en “statisk” funktion til en enum kan vi bruge en ledsagerobjekt:

ledsagende objekt {fun getCardTypeByName (name: String) = valueOf (name.toUpperCase ())}

Vi kan nu påkalde denne funktion med:

val cardType = CardType.getCardTypeByName ("SILVER")

Bemærk, at Kotlin ikke har et koncept for statisk metoder. Hvad vi har vist her en måde at få den samme funktionalitet som i Java, men ved hjælp af Kotlins funktioner.

6. Konklusion

Denne artikel giver en introduktion til enums på Kotlin-sprog, og det er nøglefunktionerne.

Vi har introduceret nogle enkle begreber som at definere enums og initialisere konstanterne. Vi har også vist nogle avancerede funktioner som at definere enum-konstanter som anonyme klasser og enums, der implementerer grænseflader.

Implementeringen af ​​alle disse eksempler og kodestykker findes i GitHub-projektet. Dette er et Maven-projekt, så det skal være let at importere og køre som det er.