Lazy property delegation in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a lazy property named value initialized with 10.

Kotlin

val value by [1] { 10 }

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

AlazyInit

Blazy

Cdelegate

DlazyValue

Attempts:

3 left

💡 Hint

Common Mistakes

Using a function name that does not exist like 'delegate' or 'lazyValue'.

Forgetting to use the 'by' keyword before the lazy function.

The lazy function is used to delegate a property that is initialized only when accessed for the first time.

2fill in blank

medium

Complete the code to print the lazy property value.

Kotlin

println([1])

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

Avalue

Blazy.value

Cvalue()

Dlazy()

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to call the property as a function with parentheses.

Using the delegate name instead of the property name.

Lazy properties are accessed like normal properties without parentheses.

3fill in blank

hard

Fix the error in the lazy property declaration by completing the code.

Kotlin

val number by [1] 42

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

Alazy {

Blazy {}

Clazy()

Dlazy

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the value directly without curly braces.

Using parentheses without a lambda block.

The lazy function requires a lambda block to initialize the value, so you must use curly braces {}.

4fill in blank

hard

Fill both blanks to create a lazy property text initialized with "Hello" and print it.

Kotlin

val text by [1] { "Hello" }
println([2])

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

Alazy

Btext()

Ctext

DlazyValue

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to call the property as a function.

Using an incorrect delegate name.

The property text is delegated by lazy and accessed directly by its name.

5fill in blank

hard

Fill all three blanks to create a lazy property count initialized with 5, print it, and then print count multiplied by 2.

Kotlin

val count by [1] { 5 }
println([2])
println([3] * 2)

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

Alazy

Bcount

DlazyValue

Attempts:

3 left

💡 Hint

Common Mistakes

Using an incorrect delegate name.

Calling the property as a function.

The property count is delegated by lazy, accessed directly to print its value and to multiply it.

Practice

1. What does lazy property delegation in Kotlin do?

easy

A. Deletes the property value after each use

B. Delays the creation of a property value until it is first accessed

C. Creates the property value immediately when the object is created

D. Allows multiple values to be stored in the same property

Solution

1. Step 1: Understand lazy delegation concept

   Lazy delegation means the property value is not created when the object is made, but only when the property is accessed for the first time.

2. Step 2: Compare options with this concept

   Delays the creation of a property value until it is first accessed matches this behavior exactly. Options A, B, and D describe different behaviors not related to lazy delegation.

3. Final Answer:

   Delays the creation of a property value until it is first accessed -> Option B

4. Quick Check:

   Lazy property = delayed creation [OK]

Hint: Lazy means create value only when first needed [OK]

Common Mistakes:

• Thinking lazy creates value immediately
• Confusing lazy with caching multiple values
• Assuming lazy deletes values after use

2. Which of the following is the correct syntax to declare a lazy property in Kotlin?

easy

A. val name = lazy("John")

B. val name = lazy { "John" }

C. val name by lazy { "John" }

D. lazy val name = "John"

Solution

1. Step 1: Recall Kotlin lazy syntax

   In Kotlin, lazy properties use the syntax: val propertyName by lazy { initializer }.

2. Step 2: Match options with correct syntax

   val name by lazy { "John" } matches this exactly. val name = lazy { "John" } assigns lazy delegate but does not use 'by'. lazy val name = "John" uses invalid order. val name = lazy("John") uses wrong function call syntax.

3. Final Answer:

   val name by lazy { "John" } -> Option C

4. Quick Check:

   Use 'by lazy { }' for lazy property [OK]

Hint: Remember: val x by lazy { ... } [OK]

Common Mistakes:

• Omitting 'by' keyword
• Using lazy() as a function call incorrectly
• Placing 'lazy' before 'val'

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

val lazyValue by lazy {
    println("Computing...")
    10
}

fun main() {
    println(lazyValue)
    println(lazyValue)
}

medium

A. Computing...\n10\n10

B. 10\n10

C. Computing...\n10\nComputing...\n10

D. Computing...\nComputing...\n10\n10

Solution

1. Step 1: Understand lazy initialization behavior

   The lambda inside lazy runs only once, when the property is first accessed. It prints "Computing..." and returns 10.

2. Step 2: Trace the program output

   First println(lazyValue) triggers lazy initialization, printing "Computing..." then 10. Second println(lazyValue) uses cached value, printing only 10.

3. Final Answer:

   Computing...\n10\n10 -> Option A

4. Quick Check:

   Lazy runs once, then caches value [OK]

Hint: Lazy block runs once, then cached value used [OK]

Common Mistakes:

• Assuming lazy block runs every access
• Missing that println inside lazy prints once
• Confusing output order

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

class Example {
    val number = lazy { 5 }
}

fun main() {
    val e = Example()
    println(e.number)
}

medium

A. The lazy block must return a String, not Int

B. The println statement is missing parentheses

C. The lazy delegate cannot be used inside a class

D. The property 'number' should be declared with 'by lazy', not assigned directly

Solution

1. Step 1: Check lazy property declaration

   The property 'number' is assigned lazy { 5 } directly, but lazy delegation requires 'by lazy' syntax.

2. Step 2: Identify correct syntax

   Correct declaration is 'val number by lazy { 5 }'. Without 'by', 'number' is a Lazy<Int> object, not the Int value.

3. Final Answer:

   The property 'number' should be declared with 'by lazy', not assigned directly -> Option D

4. Quick Check:

   Use 'by lazy' keyword for lazy properties [OK]

Hint: Lazy needs 'by lazy', not just assignment [OK]

Common Mistakes:

• Omitting 'by' keyword
• Confusing lazy delegate type with property type
• Thinking lazy only works outside classes

5. You want to create a Kotlin class where a heavy computation is done only once and reused, but the computation depends on a constructor parameter. How should you use lazy delegation to achieve this?

class Calculator(val input: Int) {
    val result by lazy { /* ??? */ }
}

Which is the correct way to implement the lazy block?

hard

A. val result by lazy { compute() } // where compute() is a member function

B. val result by lazy { Calculator(input).compute() }

C. val result by lazy { input }

D. val result by lazy { input * 2 }

Solution

1. Step 1: Understand lazy with constructor parameter

   The lazy block can access constructor parameters and member functions. Using a member function keeps code clean and reusable.

2. Step 2: Evaluate options

   val result by lazy { input * 2 } uses input directly, which works but may duplicate logic. val result by lazy { Calculator(input).compute() } creates a new Calculator inside lazy, causing recursion. val result by lazy { input } just returns input, no computation. val result by lazy { compute() } // where compute() is a member function calls a member function compute(), which can use input and perform heavy work once.

3. Final Answer:

   val result by lazy { compute() } // where compute() is a member function -> Option A

4. Quick Check:

   Use member function inside lazy for complex computation [OK]

Hint: Call member function inside lazy for complex work [OK]

Common Mistakes:

• Creating new instance inside lazy causing recursion
• Using constructor parameter directly without logic
• Returning parameter without computation