Enum-Klassen

Teil des Abschnitts Objektorientierte Programmierung der Kotlin-Journey von Coddy. Lektion 33 von 57.

Eine enum class deklariert einen Typ mit einer festen Menge von Werten, seinen Konstanten. Jede Konstante ist ein Objekt des Enums mit einem name und einem ordinal, seiner Position, beginnend bei 0. entries listet sie in der richtigen Reihenfolge auf:

enum class Direction { NORTH, EAST, SOUTH, WEST }

Innerhalb von main:

val d = Direction.EAST
println(d)
println(d.ordinal)
println(Direction.entries)

Ausgabe:

EAST
1
[NORTH, EAST, SOUTH, WEST]

Enum-Konstanten können Eigenschaften haben, die an den Konstruktor der Enum übergeben werden, und die Enum kann Methoden deklarieren. Ein Semikolon beendet die Liste der Konstanten vor den Membern:

enum class Coin(val cents: Int) {
    PENNY(1), NICKEL(5), DIME(10), QUARTER(25);

    fun label() = "${name.lowercase()} ($cents c)"
}

Innerhalb von main:

println(Coin.DIME.label())
println(Coin.entries.sumOf { it.cents })

Ausgabe:

dime (10 c)
41

Ein when über ein Enum, das jede Konstante aufführt, benötigt kein else, und der Compiler meldet eine fehlende Konstante. valueOf("SOUTH") findet eine Konstante anhand ihres exakten Namens und löst bei einer unbekannten Konstante eine Ausnahme aus; daher wird die Eingabe normalerweise mit entries.find abgeglichen:

enum class Direction { NORTH, EAST, SOUTH, WEST }

fun turnRight(d: Direction) = when (d) {
    Direction.NORTH -> Direction.EAST
    Direction.EAST -> Direction.SOUTH
    Direction.SOUTH -> Direction.WEST
    Direction.WEST -> Direction.NORTH
}

fun parse(text: String) = Direction.entries.find { it.name == text.uppercase() }

Innerhalb von main:

println(turnRight(Direction.valueOf("SOUTH")))
println(parse("north"))
println(parse("up"))

Ausgabe:

WEST
NORTH
null

Eine Konstante kann ihren eigenen Rumpf haben und dort eine Methode überschreiben. Wenn die Methode abstract im Enum deklariert wird, muss jede Konstante sie implementieren:

enum class Op(val symbol: String) {
    PLUS("+") {
        override fun apply(a: Int, b: Int) = a + b
    },
    TIMES("*") {
        override fun apply(a: Int, b: Int) = a * b
    };

    abstract fun apply(a: Int, b: Int): Int
}

Innerhalb von main:

for (op in Op.entries) println("6 ${op.symbol} 3 = ${op.apply(6, 3)}")

Ausgabe:

6 + 3 = 9
6 * 3 = 18

Aufgabe

Einfach

Vervollständige das Enum Size mit den Konstanten SMALL (250 ml, Preis 300), MEDIUM (350 ml, 380) und LARGE (500 ml, 450), wobei die Preise in Cent angegeben sind. label() gibt medium (350 ml): 3.80 zurück, und upsize() gibt die nächstgrößere Größe oder für LARGE dieselbe Größe zurück. Das Companion-Objekt parse(text) findet eine Größe anhand ihres Namens ohne Beachtung der Groß-/Kleinschreibung oder anhand ihres ersten Buchstabens (s, M) und gibt andernfalls null zurück.

Der bereitgestellte Code liest Bestellungen wie medium, L oder up small (das vergrößerte Getränk) ein und gibt jedes Label oder unknown size x aus und schließlich total: 11.10.

Dein Code gehört in Size.kt. Main.kt enthält den bereitgestellten Eingabe-/Ausgabecode und darf nicht bearbeitet werden.

Probier es selbst

fun main() {
    // Bereitgestellter Ein-/Ausgabe-Code: belasse ihn wie er ist
    val input = generateSequence(::readLine).toList()
    var total = 0
    for (line in input) {
        val upsize = line.startsWith("up ")
        val size = Size.parse(line.removePrefix("up "))
        if (size == null) {
            println("unknown size $line")
            continue
        }
        val chosen = if (upsize) size.upsize() else size
        println(chosen.label())
        total += chosen.price
    }
    println("total: %d.%02d".format(total / 100, total % 100))
}