super dan Konstruktor

Termasuk bagian Pemrograman Berorientasi Objek dalam perjalanan Kotlin di Coddy. Pelajaran 19 dari 57.

super.method() memanggil versi method dari superclass di dalam override. Subclass dapat memperluas perilaku yang diwarisi alih-alih menggantinya:

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)"
}

Di dalam main:

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

Output:

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

Setiap subclass harus memanggil constructor superclass. Dengan constructor utama, pemanggilan tersebut menjadi bagian dari header, : Base(arguments), dan argumennya dapat dihitung dari parameter subclass:

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

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

Di dalam main:

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

Output:

tea 450 (10% off)

Pembuatan berjalan dari bagian atas hierarki ke bawah: penginisialisasi property dan blok init milik superclass dijalankan terlebih dahulu, lalu milik subclass:

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

Di dalam main:

Child("kit")

Output:

Base init for KIT
Child init for kit

class tanpa konstruktor utama memanggil superclass dari setiap konstruktor sekunder dengan super(...), atau mendelegasikan ke konstruktor lain miliknya dengan this(...):

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)
}

Di dalam main:

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

Output:

rect 3x3

Karena superclass disiapkan terlebih dahulu, superclass tidak seharusnya memanggil anggota open dari konstruktornya atau init. Override dijalankan sebelum properti milik subclass memiliki nilai:

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

Di dalam main:

Child()

Output:

Base sees: label is null

Tantangan

Mudah

Notification(text) memiliki method terbuka render() yang mengembalikan [info] text. Lengkapi subclass: render() milik Warning mengembalikan [warn] TEXT dengan teks dalam huruf kapital, sedangkan Reminder, yang juga menyimpan minutes, mengembalikan hasil superclass diikuti (in 10 min), dengan menggunakan super.

Kode yang disediakan membaca baris info,text, warn,text atau remind,text,10, membuat object yang sesuai dalam satu List<Notification>, lalu mencetak render() untuk masing-masing object.

Tulis kodemu di Notification.kt, Warning.kt dan Reminder.kt. Main.kt berisi kode input/output yang disediakan dan tidak boleh diedit.

Coba sendiri

fun main() {
    // Kode input/output yang disediakan: biarkan apa adanya
    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())
}