Observable property delegation in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin code using observable delegation?

Consider the following Kotlin code that uses observable property delegation. What will be printed when the code runs?

Kotlin

import kotlin.properties.Delegates

class User {
    var name: String by Delegates.observable("Unknown") { prop, old, new ->
        println("Property '${prop.name}' changed from '$old' to '$new'")
    }
}

fun main() {
    val user = User()
    user.name = "Alice"
    user.name = "Bob"
}

A Property 'name' changed from 'Unknown' to 'Bob'

B Property 'name' changed from 'Alice' to 'Bob'

C

Property 'name' changed from 'Unknown' to 'Alice'
Property 'name' changed from 'Alice' to 'Bob'

D No output

💡 Hint

Think about how observable delegation calls the callback on every property change.

The observable delegate calls the lambda every time the property changes. Initially, the property is 'Unknown'. When set to 'Alice', the lambda prints the change from 'Unknown' to 'Alice'. Then when set to 'Bob', it prints the change from 'Alice' to 'Bob'.

🧠 Conceptual

intermediate

What is the main purpose of observable property delegation in Kotlin?

Why would a Kotlin developer use observable property delegation?

A To automatically run code whenever a property value changes

B To make a property immutable

C To delay the initialization of a property until first use

D To create a property that cannot be accessed outside the class

💡 Hint

Think about what happens when a property changes.

Observable property delegation allows running custom code whenever the property's value changes, such as logging or validation.

🔧 Debug

advanced

Why does this Kotlin code using observable delegation cause a stack overflow?

Examine the code below. Why does it cause a stack overflow error when run?

Kotlin

import kotlin.properties.Delegates

class Counter {
    var count: Int by Delegates.observable(0) { _, _, new ->
        if (new < 10) {
            count = new + 1
        }
    }
}

fun main() {
    val counter = Counter()
    counter.count = 1
    println(counter.count)
}

A Because the println statement is inside the observable callback

B Because the initial value 0 is invalid for observable properties

C Because the property count is immutable and cannot be changed

D Because the observable callback modifies the property it observes, causing infinite recursion

💡 Hint

Think about what happens when the property is changed inside its own observer.

The observable callback sets the property 'count' again, which triggers the callback again, causing infinite recursion and stack overflow.

📝 Syntax

advanced

Which option correctly declares an observable property in Kotlin?

Select the correct Kotlin syntax to declare an observable property 'score' initialized to 0 that prints changes.

A var score: Int = Delegates.observable(0) { prop, old, new -> println("Score changed from ${old} to ${new}") }

B var score: Int by Delegates.observable(0) { prop, old, new -> println("Score changed from ${old} to ${new}") }

C val score: Int by Delegates.observable(0) { prop, old, new -> println("Score changed from ${old} to ${new}") }

D var score: Int by observable(0) { prop, old, new -> println("Score changed from ${old} to ${new}") }

💡 Hint

Remember the correct syntax for property delegation uses 'by' and the delegate object.

Option B correctly uses 'var' with 'by Delegates.observable' and a lambda for the callback. Option B assigns the delegate directly to the property which is invalid. Option B uses 'val' which cannot be delegated with observable since it must be mutable. Option B uses 'observable' without 'Delegates.' which is undefined.

🚀 Application

expert

How many times will the observable callback run in this Kotlin code?

Given the code below, how many times will the observable callback print a message?

Kotlin

import kotlin.properties.Delegates

class Temperature {
    var celsius: Int by Delegates.observable(20) { _, old, new ->
        println("Temperature changed from ${old} to ${new}")
    }
}

fun main() {
    val temp = Temperature()
    temp.celsius = 25
    temp.celsius = 25
    temp.celsius = 30
}

A 2

B 1

C 0

D 3

💡 Hint

Consider if setting the same value triggers the observable callback.

The observable callback runs only when the property value actually changes. Setting the same value (25 to 25) does not trigger it. So it runs when changing from 20 to 25 and from 25 to 30, total 2 times.