Lazy property delegation in Kotlin - Mini Project: Build & Apply

Lazy Property Delegation in Kotlin

📖 Scenario: You are creating a simple Kotlin program to demonstrate how to use lazy property delegation. Imagine you have a class that calculates a value only when it is needed, like a special greeting message that is expensive to create.

🎯 Goal: Build a Kotlin class with a lazy property that initializes a greeting message only when accessed for the first time. Then, print the greeting message.

📋 What You'll Learn

Create a class called Greeter.

Inside Greeter, create a lazy property called greeting that returns the string "Hello, Kotlin!".

Create an instance of Greeter.

Access and print the greeting property.

💡 Why This Matters

🌍 Real World

Lazy properties are useful when you want to delay expensive calculations or resource loading until they are actually needed, like loading user data or configuration settings.

💼 Career

Understanding lazy property delegation helps you write efficient Kotlin code, which is valuable for Android development and backend services where performance matters.

1

Create the Greeter class

Create a Kotlin class called Greeter with no properties or functions yet.

Kotlin

class Greeter {
    // Your code here
}

Hint

Use the class keyword followed by the class name Greeter.

2

Add a lazy property called greeting

Inside the Greeter class, add a lazy property called greeting that returns the string "Hello, Kotlin!". Use Kotlin's by lazy syntax.

Kotlin

class Greeter {
    val greeting: String by lazy {
        // Your code here
    }
}

Hint

Use val greeting: String by lazy { "Hello, Kotlin!" } inside the class.

3

Create an instance of Greeter

Outside the Greeter class, create a variable called greeter and assign it a new instance of Greeter().

Kotlin

class Greeter {
    val greeting: String by lazy {
        "Hello, Kotlin!"
    }
}

// Your code here

Hint

Use val greeter = Greeter() to create the instance.

4

Print the greeting property

Print the greeting property of the greeter instance using println.

Kotlin

class Greeter {
    val greeting: String by lazy {
        "Hello, Kotlin!"
    }
}

val greeter = Greeter()

// Your code here

Hint

Use println(greeter.greeting) to display the greeting.

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