Class delegation with by keyword in Kotlin - Time & Space Complexity

Time Complexity: Class delegation with by keyword

O(n)

Understanding Time Complexity

We want to understand how the time it takes to run code changes when using class delegation with the by keyword in Kotlin.

Specifically, we ask: how does delegation affect the number of steps the program takes as input grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

interface Printer {
    fun printMessage(message: String)
}

class ConsolePrinter : Printer {
    override fun printMessage(message: String) {
        println(message)
    }
}

class DelegatingPrinter(printer: Printer) : Printer by printer

fun main() {
    val printer = DelegatingPrinter(ConsolePrinter())
    printer.printMessage("Hello, Kotlin!")
}

This code shows a class DelegatingPrinter that uses the by keyword to delegate its Printer interface methods to another object.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Calling the delegated method printMessage.
• How many times: Exactly once per call in this example.

How Execution Grows With Input

The program runs the delegated method once each time it is called, regardless of input size.

Input Size (n)	Approx. Operations
10	10 calls to printMessage, 10 delegated calls
100	100 calls to printMessage, 100 delegated calls
1000	1000 calls to printMessage, 1000 delegated calls

Pattern observation: The number of operations grows directly with the number of calls, one-to-one.

Final Time Complexity

Time Complexity: O(n)

This means the time grows linearly with the number of method calls delegated.

Common Mistake

[X] Wrong: "Delegation adds extra loops or slows down the program exponentially."

[OK] Correct: Delegation just forwards calls directly without extra loops, so it does not multiply the work beyond the original calls.

Interview Connect

Understanding delegation helps you explain how Kotlin handles code reuse efficiently, a useful skill when discussing design and performance.

Self-Check

What if the delegated method itself contained a loop over input data? How would that affect the overall time complexity?