Class declaration syntax in Kotlin - Time & Space Complexity

Time Complexity: Class declaration syntax

O(n)

Understanding Time Complexity

Let's see how the time it takes to create a class grows as we add more properties or methods.

We want to know how the work changes when the class size changes.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Person(val name: String, val age: Int) {
    fun greet() {
        println("Hello, my name is $name.")
    }
}

fun main() {
    val person = Person("Alice", 30)
    person.greet()
}
    

This code defines a simple class with two properties and one method, then creates an object and calls the method.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Creating an instance of the class and calling its method.
• How many times: Once in this example, no loops or repeated calls.

How Execution Grows With Input

When we add more properties or methods, creating the class and its objects takes more steps.

Input Size (number of properties/methods)	Approx. Operations
1	Few steps to set up and call
5	More steps to initialize and manage
10	Even more steps, roughly growing with number of members

Pattern observation: The work grows roughly in a straight line as you add more parts to the class.

Final Time Complexity

Time Complexity: O(n)

This means the time to create and use the class grows linearly with the number of properties and methods it has.

Common Mistake

[X] Wrong: "Creating a class is always instant and does not depend on its size."

[OK] Correct: Even though creating an instance looks simple, the computer does more work as the class has more parts to set up.

Interview Connect

Understanding how class size affects work helps you explain your code design choices clearly and confidently.

Self-Check

"What if we added a loop inside the class method that runs over a list of size n? How would the time complexity change?"