Observable property delegation in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare an observable property with initial value 10.

Kotlin

var score: Int by [1](10) { prop, old, new ->
    println("Score changed from $old to $new")
}

Drag options to blanks, or click blank then click option'

ADelegates.observable

Blazy

Cval

Dlateinit

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'lazy' instead of 'observable' delegate.

Trying to declare the property as 'val' which is immutable.

Using 'lateinit' which is not a delegate.

The Delegates.observable function creates an observable property that calls the lambda whenever the value changes.

2fill in blank

medium

Complete the code to print the old and new values when the property changes.

Kotlin

var name: String by Delegates.observable("John") { [1], old, new ->
    println("Name changed from $old to $new")
}

Drag options to blanks, or click blank then click option'

Aproperty

Bprop

Cthis

Dobj

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'this' which refers to the enclosing class, not the property.

Using 'obj' which is not a standard parameter name here.

The lambda receives three parameters: the property, the old value, and the new value. The property parameter is commonly named prop.

3fill in blank

hard

Fix the error in the observable delegate usage.

Kotlin

var age: Int by Delegates.observable([1]) { prop, old, new ->
    println("Age changed from $old to $new")
}

Drag options to blanks, or click blank then click option'

Anull

B"25"

C25

Dage

Attempts:

3 left

💡 Hint

Common Mistakes

Using a string "25" instead of integer 25.

Using null which is not allowed here.

The initial value must be an Int, so 25 without quotes is correct. Quotes make it a String, causing a type error.

4fill in blank

hard

Fill both blanks to create an observable property that prints a message only when the new value is greater than the old value.

Kotlin

var level: Int by Delegates.observable(1) { prop, old, new ->
    if (new [1] old) {
        println("Level increased to $new")
    }
}

Drag options to blanks, or click blank then click option'

A>

B<

C!=

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' which triggers on decrease.

Using '==' which triggers only on equality.

The condition new > old checks if the new value is greater than the old one, triggering the print only on increase.

5fill in blank

hard

Fill the two blanks to create an observable property that prints the change only when the new value is different from the old value.

Kotlin

var status: String by Delegates.observable("idle") { [1], old, new ->
    if (new [2] old) {
        println("Status changed from $old to $new")
    }
}

Drag options to blanks, or click blank then click option'

Aprop

B!=

C==

Dproperty

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' instead of '!=' causing print on no change.

Using wrong parameter names causing errors.

The lambda receives three parameters: the property (named prop), the old value, and the new value. The condition new != old ensures printing only on actual changes.

Practice

1. What does observable property delegation in Kotlin do?

easy

A. It delays the initialization of a property until first use.

B. It makes a property immutable and unchangeable.

C. It automatically converts a property to a string.

D. It watches a property and runs code when the property value changes.

Solution

1. Step 1: Understand observable delegation purpose

   Observable delegation lets you watch a property for changes and react when it changes.

2. Step 2: Compare options with definition

   Only It watches a property and runs code when the property value changes. describes this behavior correctly; others describe different Kotlin features.

3. Final Answer:

   It watches a property and runs code when the property value changes. -> Option D

4. Quick Check:

   Observable delegation = watch property changes [OK]

Hint: Observable runs code on property change, not on initialization [OK]

Common Mistakes:

• Confusing observable with lazy initialization
• Thinking observable makes property immutable
• Assuming observable converts types automatically

2. Which of the following is the correct syntax to declare an observable property in Kotlin?

easy

A. var name: String by observable("") { prop, old, new -> println("Changed") }

B. var name: String = observable("") { prop, old, new -> println("Changed") }

C. val name: String by observable("") { prop, old, new -> println("Changed") }

D. var name: String observable("") { prop, old, new -> println("Changed") }

Solution

1. Step 1: Recall observable property syntax

   Observable properties use by observable(initialValue) { prop, old, new -> ... } with var.

2. Step 2: Check each option

   var name: String by observable("") { prop, old, new -> println("Changed") } matches correct syntax. var name: String = observable("") { prop, old, new -> println("Changed") } uses wrong assignment. val name: String by observable("") { prop, old, new -> println("Changed") } uses val which is immutable. var name: String observable("") { prop, old, new -> println("Changed") } misses by.

3. Final Answer:

   var name: String by observable("") { prop, old, new -> println("Changed") } -> Option A

4. Quick Check:

   Use 'var' and 'by observable' syntax [OK]

Hint: Use 'var' with 'by observable' and initial value [OK]

Common Mistakes:

• Using val instead of var for observable
• Omitting 'by' keyword
• Assigning observable without 'by'

3. What will be the output of this Kotlin code?

import kotlin.properties.Delegates

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

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

medium

A. Name changed from Unknown to Alice

B. Name changed from Alice to Bob

C. Name changed from Unknown to Alice
Name changed from Alice to Bob

D. No output

Solution

1. Step 1: Understand observable callback calls

   The observable lambda runs every time the property changes, printing old and new values.

2. Step 2: Trace property changes in main()

   Initially name is "Unknown". First change to "Alice" triggers print. Second change to "Bob" triggers print again.

3. Final Answer:

   Name changed from Unknown to Alice Name changed from Alice to Bob -> Option C

4. Quick Check:

   Observable prints on each change [OK]

Hint: Observable prints on every property change [OK]

Common Mistakes:

• Thinking only last change triggers print
• Ignoring initial value in output
• Expecting output without property change

4. Identify the error in this Kotlin code using observable delegation:

import kotlin.properties.Delegates

class Counter {
    var count: Int by Delegates.observable(0) { prop, old, new ->
        if (new < old) {
            println("Count cannot decrease")
        }
    }
}

fun main() {
    val c = Counter()
    c.count = 5
    c.count = 3
}

medium

A. Logical error: observable does not prevent count from decreasing.

B. Syntax error: '<' should be '<' without escaping.

C. Runtime error: observable lambda cannot have if statements.

D. No error; code works as expected printing a warning when count decreases.

Solution

1. Step 1: Check syntax and runtime correctness

   The code syntax is correct; escaped '<' is valid in HTML but in code it should be '<'. Assuming code runs, no syntax error.

2. Step 2: Analyze observable behavior

   The observable lambda prints a message if count decreases but does not stop the change. So count can decrease despite warning.

3. Final Answer:

   Logical error: observable does not prevent count from decreasing. -> Option A

4. Quick Check:

   Observable reacts but does not block changes [OK]

Hint: Observable warns but doesn't stop changes automatically [OK]

Common Mistakes:

• Expecting observable to block property changes
• Confusing HTML escape with Kotlin syntax
• Thinking if statement causes runtime error

5. You want to create a Kotlin class Temperature with an observable property celsius. When celsius changes, it should update another property fahrenheit automatically. Which code correctly implements this behavior?

hard

A. class Temperature {
var celsius: Double = 0.0
var fahrenheit: Double by Delegates.observable(32.0) { _, _, new ->
celsius = (new - 32) * 5 / 9
}
}

B. class Temperature {
var celsius: Double by Delegates.observable(0.0) { _, _, new ->
fahrenheit = new * 9 / 5 + 32
}
var fahrenheit: Double = 32.0
}

C. class Temperature {
var celsius: Double by Delegates.observable(0.0) { _, _, new ->
fahrenheit = new + 32
}
var fahrenheit: Double = 32.0
}

D. class Temperature {
var celsius: Double by Delegates.observable(0.0) { _, _, new ->
fahrenheit = new * 5 / 9 + 32
}
var fahrenheit: Double = 32.0
}

Solution

1. Step 1: Understand temperature conversion formulas

   Fahrenheit = Celsius * 9/5 + 32. class Temperature { var celsius: Double by Delegates.observable(0.0) { _, _, new -> fahrenheit = new * 9 / 5 + 32 } var fahrenheit: Double = 32.0 } uses this formula correctly.

2. Step 2: Check observable updates fahrenheit on celsius change

   class Temperature { var celsius: Double by Delegates.observable(0.0) { _, _, new -> fahrenheit = new * 9 / 5 + 32 } var fahrenheit: Double = 32.0 } updates fahrenheit inside observable lambda of celsius, which is correct behavior.

3. Final Answer:

   class Temperature { var celsius: Double by Delegates.observable(0.0) { _, _, new -> fahrenheit = new * 9 / 5 + 32 } var fahrenheit: Double = 32.0 } -> Option B

4. Quick Check:

   Use correct formula and update fahrenheit in celsius observable [OK]

Hint: Use correct formula and update dependent property inside observable [OK]

Common Mistakes:

• Using wrong temperature conversion formula
• Updating celsius inside fahrenheit observable causing infinite loop
• Adding instead of multiplying in formula