8. Klassen und Objekte

class Hund(val name: String, var alter: Int) { // Attribute im Konstruktor
    var hunger = 5                // weiteres Attribut mit Startwert

    init {                        // wird beim Erzeugen ausgeführt
        println("$name wurde erzeugt")
    }

    fun bellen() {                // Methode ohne Rückgabe
        println("$name: Wuff!")
    }

    fun istHungrig(): Boolean {   // Methode mit Rückgabe
        return hunger > 3
    }

    override fun toString(): String { // Text für println(hund)
        return "Hund $name ($alter Jahre)"
    }
}

val bello = Hund("Bello", 3)      // Objekt erzeugen (Konstruktoraufruf)
bello.bellen()                    // Methode aufrufen
bello.alter = 4                   // Attribut ändern (nur bei var)
println(bello.name)               // Attribut lesen: → Bello
println(bello)                    // → Hund Bello (4 Jahre)

9. Datenkapselung

class Konto {
    private var pin = 1234        // nur innerhalb der Klasse zugreifbar
    var kontostand = 0.0
        private set               // von außen nur lesbar

    var limit = 100
        set(wert) {               // eigener Setter
            if (wert >= 0) {
                field = wert      // field: der gespeicherte Wert
            }
        }

    val istLeer: Boolean          // abgeleitetes Attribut
        get() = kontostand == 0.0 // eigener Getter

    private fun pinPruefen(eingabe: Int): Boolean { // private Methode
        return eingabe == pin
    }
}

class Mensch(startAlter: Int) {   // ohne val/var: nur Parameter, kein Attribut
    var alter = 0
        set(wert) {
            if (wert >= 0) {
                field = wert
            }
        }

    init {
        alter = startAlter        // Setter prüft auch den Startwert
    }
}

10. Vererbung

open class Tier(val name: String) {     // open: Vererbung erlaubt
    open fun lautGeben() {              // open: darf überschrieben werden
        println("...")
    }
}

class Kuh(name: String) : Tier(name) {  // Kuh erbt von Tier
    override fun lautGeben() {          // Methode überschreiben
        super.lautGeben()               // Methode der Oberklasse aufrufen
        println("Muh")
    }

    fun melken() {
        println("$name wird gemolken")
    }
}

val tier: Tier = Kuh("Berta")           // eine Kuh ist auch ein Tier
tier.lautGeben()                        // → ... Muh (Methode von Kuh)
if (tier is Kuh) {                      // Typ prüfen
    tier.melken()                       // danach als Kuh nutzbar
}

11. Abstrakte Klassen und Interfaces

abstract class Form {                   // davon gibt es keine Objekte
    abstract fun flaeche(): Double      // muss überschrieben werden

    fun beschreiben() {
        println("Fläche: ${flaeche()}")
    }
}

class Quadrat(val seite: Double) : Form() {
    override fun flaeche(): Double {
        return seite * seite
    }
}

interface Zeichenbar {                  // Interface: legt Methoden fest
    fun zeichnen()
}

class Stern : Zeichenbar {              // bei Interfaces keine ()
    override fun zeichnen() {
        println("*")
    }
}

class Kreis(val radius: Double) : Form(), Zeichenbar { // Klasse und Interface
    override fun flaeche(): Double {
        return PI * radius * radius
    }

    override fun zeichnen() {
        println("O")
    }
}