super und Konstruktoren

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

super.method() ruft innerhalb einer Überschreibung die Version einer Methode aus der Oberklasse auf. Eine Unterklasse kann das geerbte Verhalten erweitern, anstatt es zu ersetzen:

open class Notification(val text: String) {
    open fun render() = "[info] $text"
}
class Reminder(text: String, val minutes: Int) : Notification(text) {
    override fun render() = super.render() + " (in $minutes min)"
}

Innerhalb von main:

println(Notification("backup done").render())
println(Reminder("meeting", 10).render())

Ausgabe:

[info] backup done
[info] meeting (in 10 min)

Jede Unterklasse muss einen Konstruktor der Oberklasse aufrufen. Bei einem primären Konstruktor ist der Aufruf Teil des Headers, : Base(arguments), und die Argumente können aus den Parametern der Unterklasse berechnet werden:

open class Product(val name: String, val price: Int)

class Discounted(name: String, price: Int, val percent: Int) :
    Product(name, price * (100 - percent) / 100)

Innerhalb von main:

val tea = Discounted("tea", 500, 10)
println("${tea.name} ${tea.price} (${tea.percent}% off)")

Ausgabe:

tea 450 (10% off)

Die Erstellung läuft von oben nach unten in der Hierarchie ab: Die Eigenschaftsinitialisierer und init-Blöcke der Oberklasse werden zuerst ausgeführt, dann die der Unterklasse:

open class Base(name: String) {
    init { println("Base init for $name") }
}
class Child(name: String) : Base(name.uppercase()) {
    init { println("Child init for $name") }
}

Innerhalb von main:

Child("kit")

Ausgabe:

Base init for KIT
Child init for kit

Eine Klasse ohne primären Konstruktor ruft die Oberklasse aus jedem sekundären Konstruktor mit super(...) auf oder delegiert mit this(...) an einen anderen ihrer eigenen Konstruktoren:

open class Shape(val name: String)

class Rect : Shape {
    val w: Int
    val h: Int

    constructor(w: Int, h: Int) : super("rect") {
        this.w = w
        this.h = h
    }

    constructor(side: Int) : this(side, side)
}

Innerhalb von main:

val r = Rect(3)
println("${r.name} ${r.w}x${r.h}")

Ausgabe:

rect 3x3

Da die Oberklasse zuerst eingerichtet wird, sollte sie aus ihrem Konstruktor oder aus init keine open-Member aufrufen. Die Überschreibung wird ausgeführt, bevor die eigenen Eigenschaften der Unterklasse ihre Werte haben:

open class Base {
    init { println("Base sees: ${describe()}") }
    open fun describe() = "base"
}
class Child : Base() {
    val label = "child"
    override fun describe() = "label is $label"
}

Innerhalb von main:

Child()

Ausgabe:

Base sees: label is null

Aufgabe

Einfach

Notification(text) verfügt über eine offene Methode render(), die [info] text zurückgibt. Vervollständige die Unterklassen: render() von Warning gibt [warn] TEXT zurück, wobei der Text in Großbuchstaben geschrieben wird, und Reminder, das zusätzlich minutes speichert, gibt das Ergebnis der Oberklasse gefolgt von (in 10 min) zurück und verwendet dazu super.

Der bereitgestellte Code liest Zeilen im Format info,text, warn,text oder remind,text,10, erstellt das passende Objekt in einer List<Notification> und gibt für jedes Objekt render() aus.

Dein Code gehört in Notification.kt, Warning.kt und Reminder.kt. Main.kt enthält den bereitgestellten Eingabe-/Ausgabecode und kann nicht bearbeitet werden.

Probier es selbst

fun main() {
    // Gelieferter Ein-/Ausgabecode: belasse ihn wie er ist
    val input = generateSequence(::readLine).toList()
    val notes = mutableListOf<Notification>()
    for (line in input) {
        val p = line.split(",")
        notes.add(when (p[0]) {
            "warn" -> Warning(p[1])
            "remind" -> Reminder(p[1], p[2].toInt())
            else -> Notification(p[1])
        })
    }
    for (n in notes) println(n.render())
}