Zugriff auf Attribute limitieren

Wir haben gesehen, dass es zu Problemen führen kann, wenn man uneingeschränkten Zugriff auf die Attribute einer Klasse hat. Es gibt verschiedene Möglichkeiten, um den Zugriff auf Attribute einzuschränken. Das Begrenzen des Zugriffs erreicht man mit Hilfe des Konzepts der Datenkapselung. Man kann dabei unterschiedlich stark einschränken, wie man auf Attribute zugreifen kann. Es ist z.B. möglich, den schreibenden oder lesenden Zugriff zu steuern, oder sogar Attribute komplett zu verstecken, so dass man gar nicht mehr auf sie außerhalb der Klasse zugreifen kann.

Standard-Setter

Wenn man ein Attribut definiert, ergänzt der Compiler automatisch einen sogenannten Setter, der den schreibenden Zugriff auf das Attribut steuert. Du siehst den Standard-Setter nicht in dem von dir geschriebenen Code, aber er wird beim Übersetzen in das ausführbare Programm automatisch hinzugefügt.

Ein Setter sieht so ähnlich aus wie eine Methode. In einigen Sprachen schreibt man dafür tatsächlich eine Methode, in Kotlin gibt es eine spezielle Syntax für den Setter. Den Standard-Setter würde man in Kotlin so schreiben:

class Timer {
    var min: Int = 0
        set(value) {
            field = value
        }
    
    // Rest der Klasse ...
}

fun main() {
    val timer = Timer()
    timer.min = 5 // Hier wird automatisch der Setter aufgerufen
    println(timer.min)
}

Aufgabe 1

Schreibenden Zugriff auf Attribute steuern

Um zu verhindern, dass Attribute unsinnig verändert werden können, kannst du den Setter so anpassen, dass er den neuen Wert überprüft, bevor er ihn tatsächlich in das Attribut schreibt.

class Timer {
    var min: Int = 0
        set(value) {
            if (value < 0) {
                field = 0
            } else {
                field = value
            }
        }
}

fun main() {
    val timer = Timer()
    timer.min = -5
    println(timer.min)
}

Aufgabe 2

Komplexere Bedingungen

In den obigen Settern haben wir einfache Bedingungen formuliert, die nur einen Vergleich enthalten, z.B. value < 0 oder value >= min. Manchmal möchte man komplexere Bedingungen formulieren, die z.B. dann wahr sind, wenn mehrere einfache Bedingungen gleichzeitig erfüllt sind, oder wenn mindestens eine von mehreren einfachen Bedingungen erfüllt ist. Dafür gibt es logische Operatoren. In Kotlin gibt es die logischen Operatoren && (logisches Und), || (logisches Oder) und ! (logisches Nicht). Mit diesen Operatoren kannst du komplexe Bedingungen formulieren, z.B.:

fun main() {
    val zahl1 = 2
    val zahl2 = 5

    if (zahl1 == zahl2 && zahl1 == 6) {
        println("Glückwunsch, du hast einen Sechserpasch gewürfelt!")
    }

    if (zahl1 == 6 || zahl2 == 6) {
        println("Glückwunsch, du hast mindestens eine Sechs gewürfelt!")
    }

    if (!(zahl1 == zahl2)) {
        println("Leider Pech gehabt, die Zahlen sind unterschiedlich.")
    }
}

Logische Operatoren kannst du natürlich nicht nur in Settern verwenden, sondern überall dort, wo du Bedingungen formulieren möchtest.

Aufgabe 3

Aufgabe 4

class Timer {
    var min: Int = 0
    var max: Int = 0

    fun starten() {
        // Den Inhalt dieser Methode musst du nicht verstehen.
        // Du musst nur wissen, dass die Methode den Timer startet.
        val bis = if (max <= min) max else min + java.util.Random().nextInt(max - min)

        for (i in 0 until bis) {
            try {
                Thread.sleep(1000)
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }

        println("Timer abgelaufen!")
    }
}

fun main() {
    val timer = Timer()
    // Hier solltest du den Timer noch testen
}