0Pricing
Kotlin Academy · Lektion

observable- und vetoable-Delegates

Reagieren Sie mit observable auf Property-Änderungen und lehnen Sie sie mit vetoable bedingt ab.

observable- und vetoable-Delegates ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Auffrischung zu Property-Delegates

Kotlin-Property-Delegates ermöglichen es einem separaten Objekt, getValue und setValue zu verarbeiten. Delegates.observable und Delegates.vetoable sind integrierte Delegates aus der Standardbibliothek.

import kotlin.properties.Delegates
var name: String by Delegates.observable("initial") { prop, old, new ->
    println("${prop.name}: $old -> $new")
}
fun main() { name = "Alice"; name = "Bob" }

observable-Syntax

observable nimmt einen Anfangswert und einen Callback entgegen, der nach jeder Änderung mit der Property, dem alten Wert und dem neuen Wert aufgerufen wird.

import kotlin.properties.Delegates
var score: Int by Delegates.observable(0) { _, old, new ->
    println("Score changed from $old to $new")
}
fun main() {
    score = 10
    score = 25
    score = 0
}

UI-Aktualisierungen auslösen

Observable-Delegates eignen sich hervorragend, um bei einer Änderung einer zugrunde liegenden Property eine UI-Aktualisierung auszulösen, ohne eine vollständige LiveData-Konfiguration einzurichten.

import kotlin.properties.Delegates
class ViewModel {
    var title: String by Delegates.observable("Loading") { _, _, new ->
        println("Render: $new") // pretend this updates UI
    }
}
fun main() {
    val vm = ViewModel()
    vm.title = "Home"
    vm.title = "Settings"
}

vetoable-Syntax

vetoable ruft einen Callback vor der Zuweisung auf. Gibt der Callback false zurück, wird der neue Wert abgelehnt und der alte Wert beibehalten.

import kotlin.properties.Delegates
var age: Int by Delegates.vetoable(0) { _, old, new ->
    new >= 0 // reject negative ages
}
fun main() {
    age = 25; println(age)  // 25
    age = -1; println(age)  // 25 (rejected)
    age = 30; println(age)  // 30
}

Validierung mit vetoable kombinieren

Verwenden Sie vetoable, um Domäneninvarianten auf Property-Ebene durchzusetzen, ohne externe Validierungslogik zu benötigen.

import kotlin.properties.Delegates
var email: String by Delegates.vetoable("") { _, _, new ->
    new.contains("@")
}
fun main() {
    email = "user@example.com"; println(email) // set
    email = "invalid";          println(email) // still previous
}

Änderungen mit observable protokollieren

Verwenden Sie observable für Audit-Protokollierung: Zeichnen Sie jeden Zustandsübergang automatisch auf, ohne die Geschäftslogik zu verändern.

import kotlin.properties.Delegates
val log = mutableListOf<String>()
var status: String by Delegates.observable("IDLE") { _, old, new ->
    log.add("$old -> $new")
}
fun main() {
    status = "RUNNING"
    status = "DONE"
    println(log)
}

observable in einer Klasse

Beide Delegates funktionieren innerhalb von Klassenkörpern wie jede andere Property auch.

import kotlin.properties.Delegates
class Counter {
    var count: Int by Delegates.observable(0) { _, old, new ->
        if (new > old) println("Incremented to $new")
        else println("Decremented to $new")
    }
}
fun main() {
    val c = Counter()
    c.count = 5
    c.count = 3
}

vetoable für Bereichsbeschränkungen

Begrenzen Sie eine numerische Property mit vetoable auf einen gültigen Wertebereich.

import kotlin.properties.Delegates
var volume: Int by Delegates.vetoable(50) { _, _, new ->
    new in 0..100
}
fun main() {
    volume = 80;  println(volume) // 80
    volume = 150; println(volume) // 80 (rejected)
    volume = 0;   println(volume) // 0
}

Delegates verketten

Sie können observable-Logik manuell kombinieren, indem Sie einen benutzerdefinierten Delegate schreiben, der intern observable aufruft und bei jedem Schritt zusätzliche Logik ausführt.

import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty
class LoggedDelegate<T>(initial: T) : ReadWriteProperty<Any?, T> {
    private var value: T = initial
    override fun getValue(t: Any?, p: KProperty<*>) = value
    override fun setValue(t: Any?, p: KProperty<*>, v: T) {
        println("Setting ${p.name} = $v"); value = v
    }
}
var x: Int by LoggedDelegate(0)
fun main() { x = 10; x = 20 }

Hinweis zur Thread-Sicherheit

Weder observable noch vetoable ist standardmäßig thread-sicher. Schützen Sie bei nebenläufigem Zugriff Änderungen mit einem Mutex oder synchronisieren Sie sie extern.

import kotlin.properties.Delegates
// Not thread-safe as-is:
var sharedState: String by Delegates.observable("start") { _, old, new ->
    println("$old -> $new")
}
// In coroutines, wrap access with Mutex if needed

Praxis-Muster: Formularvalidierung

Verwenden Sie vetoable pro Feld für deklarative Formularvalidierung: Jedes Feld validiert sich bei der Zuweisung selbst.

import kotlin.properties.Delegates
data class Form(
    var username: String = "",
    var password: String = ""
) {
    var validUsername: String by Delegates.vetoable("") { _,_,v -> v.length >= 3 }
    var validPassword: String by Delegates.vetoable("") { _,_,v -> v.length >= 8 }
}
fun main() {
    val f = Form()
    f.validUsername = "ab";       println(f.validUsername) // ""
    f.validUsername = "alice";    println(f.validUsername) // "alice"
    f.validPassword = "short";    println(f.validPassword) // ""
    f.validPassword = "secure123";println(f.validPassword) // "secure123"
}

Kurztest

Wann ruft vetoable seinen Callback auf?

Zusammenfassung

observable benachrichtigt nach jeder Änderung; vetoable wird vor der Zuweisung ausgeführt und kann den neuen Wert ablehnen. Beide eignen sich hervorragend für Protokollierung, Validierung und reaktive Property-Muster ohne externe Bibliotheken.

Häufig gestellte Fragen

Ist die Lektion „observable- und vetoable-Delegates“ kostenlos?

Ja — der vollständige Text von „observable- und vetoable-Delegates“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „observable- und vetoable-Delegates“?

Reagieren Sie mit observable auf Property-Änderungen und lehnen Sie sie mit vetoable bedingt ab. Du übst Kotlin Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Kotlin Academy zu starten?

Keine Vorkenntnisse erforderlich. Kotlin Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „observable- und vetoable-Delegates“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Kotlin Academy-Lektion Code schreiben und ausführen?

Ja. Jede Kotlin Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. by lazy: Vertiefung zur verzögerten Initialisierung
  2. observable- und vetoable-Delegates
  3. Einen benutzerdefinierten ReadWriteProperty-Delegate schreiben
  4. Delegates für Preferences, Map-basierte Properties und Logging
← Zurück zu Kotlin Academy