Mit Enums in Kotlin arbeiten

Arbeiten mit Enums in Kotlin

1. Überblick

In diesem Tutorial werden wir uns eingehend mit Kotlin-Enums befassen.

Mit der Entwicklung der Programmiersprachen hat sich auch die Verwendung und Anwendung von Aufzählungen verbessert.

Enum constants today aren’t just mere collections of constants - Sie können Eigenschaften haben, Schnittstellen implementieren und vieles mehr.

Lesen Sie für Kotlin-Anfänger diesen Artikel über Kotlin-Grundlagen -Introduction to the Kotlin Language.

2. Grundlegende Kotlin-Aufzählungen

Sehen wir uns die Grundlagen von Aufzählungen in Kotlin an.

2.1. Aufzählungen definieren

Definieren wir eine Enumeration mit drei Konstanten, die die Kreditkartentypen beschreiben:

enum class CardType {
    SILVER, GOLD, PLATINUM
}

2.2. Initialisieren von Enum-Konstanten

Enums in Kotlin, just like in Java, can have a constructor. Da Enum-Konstanten Instanzen einerEnum-Klasse sind, können die Konstanten durch Übergabe bestimmter Werte an den Konstruktor initialisiert werden.

Geben Sie Farbwerte für verschiedene Kartentypen an:

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

Wir können auf den Farbwert eines bestimmten Kartentyps zugreifen mit:

val color = CardType.SILVER.color

3. Enum-Konstanten als anonyme Klassen

Wir können ein bestimmtes Verhalten von Enum-Konstanten definieren, indem wir sie als anonyme Klassen erstellen. Konstanten müssen dann die abstrakten Funktionen überschreiben, die in der Definition vonEnumdefiniert sind.

Beispielsweise haben wir für jeden Kartentyp möglicherweise eine andere Cashback-Berechnung.

Mal sehen, wie wir es umsetzen können:

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
}

Wir können die überschriebenen Methoden der anonymen Konstantenklassen aufrufen mit:

val cashbackPercent = CardType.SILVER.calculateCashbackPercent()

4. Enums Implementing Interfaces

Angenommen, es gibt eineICardLimit-Schnittstelle, die die Kartenlimits verschiedener Kartentypen definiert:

interface ICardLimit {
    fun getCreditLimit(): Int
}

Nun wollen wir sehen, wie unsere Aufzählung diese Schnittstelle implementieren kann:

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

Um auf das Kreditlimit eines Kartentyps zuzugreifen, können wir den gleichen Ansatz wie im vorherigen Beispiel verwenden:

val creditLimit = CardType.PLATINUM.getCreditLimit()

5. Gemeinsame Enum-Konstrukte

5.1. Aufrufen von Enum-Konstanten nach Namen

Um eine Enum-Konstante anhand ihresString-Namens zu erhalten, verwenden wir die statische FunktionvalueOf():

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

5.2. Durch Aufzählungskonstanten iterieren

Um alle Enum-Konstanten zu durchlaufen, verwenden wir die statische Funktionvalues():

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

5.3. Statische Methoden

Um einer Aufzählung eine „statische“ Funktion hinzuzufügen, können wircompanion object verwenden:

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

Wir können diese Funktion jetzt aufrufen mit:

val cardType = CardType.getCardTypeByName("SILVER")

Beachten Sie, dass Kotlin kein Konzept fürstatic-Methoden hat. Was wir hier gezeigt haben, ist eine Möglichkeit, die gleiche Funktionalität wie in Java zu erhalten, jedoch die Kotlin-Funktionen zu verwenden.

6. Fazit

Dieser Artikel bietet eine Einführung in Aufzählungen in Kotlin-Sprache sowie in die wichtigsten Funktionen.

Wir haben einige einfache Konzepte wie das Definieren von Aufzählungen und das Initialisieren der Konstanten eingeführt. Wir haben auch einige erweiterte Funktionen gezeigt, wie das Definieren von Enum-Konstanten als anonyme Klassen und Enums, die Schnittstellen implementieren.

Die Implementierung all dieser Beispiele und Codefragmente finden Sie inthe GitHub project. Dies ist ein Maven-Projekt, daher sollte es einfach zu importieren und auszuführen sein.

TOC