Why classes define behavior and state in Kotlin - Performance Analysis

Time Complexity: Why classes define behavior and state

O(n)

Understanding Time Complexity

When we use classes in Kotlin, they hold data and actions together. Understanding how time grows when using classes helps us write better programs.

We want to know how the program's work changes as we create or use more objects.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Counter {
    var count = 0
    fun increment() {
        count += 1
    }
}

fun main() {
    val counters = List(1000) { Counter() }
    counters.forEach { it.increment() }
}
    

This code creates many Counter objects and calls their increment method once each.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Calling increment() on each Counter object.
• How many times: Once for each object in the list (1000 times in this example).

How Execution Grows With Input

As the number of Counter objects grows, the total work grows too because we call increment on each one.

Input Size (n)	Approx. Operations
10	10 increments
100	100 increments
1000	1000 increments

Pattern observation: The work grows directly with the number of objects.

Final Time Complexity

Time Complexity: O(n)

This means if you double the number of objects, the work doubles too.

Common Mistake

[X] Wrong: "Creating many objects at once is instant and does not affect performance."

[OK] Correct: Each object takes time to create and use, so more objects mean more work overall.

Interview Connect

Understanding how using many objects affects program speed shows you know how to write clear and efficient code. This skill helps in many coding situations.

Self-Check

"What if we called increment() multiple times per object? How would the time complexity change?"