Companion objects as static alternatives in Kotlin - Time & Space Complexity

Time Complexity: Companion objects as static alternatives

O(n)

Understanding Time Complexity

We want to understand how using companion objects affects the time it takes to run code.

Specifically, we ask: how does accessing companion object members scale as the program runs?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Calculator {
    companion object {
        fun add(a: Int, b: Int): Int {
            return a + b
        }
    }
}

fun main() {
    repeat(1000) {
        Calculator.add(it, it * 2)
    }
}
    

This code calls a companion object function many times to add numbers.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Calling the companion object function add inside a loop.
• How many times: 1000 times, once per loop iteration.

How Execution Grows With Input

Each time we increase the number of calls, the total work grows in direct proportion.

Input Size (n)	Approx. Operations
10	10 calls to add
100	100 calls to add
1000	1000 calls to add

Pattern observation: The total work grows evenly as the number of calls increases.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows directly with the number of times we call the companion object function.

Common Mistake

[X] Wrong: "Using companion objects makes function calls instantaneous or free."

[OK] Correct: Even though companion objects act like static members, each function call still takes time, so more calls mean more work.

Interview Connect

Understanding how companion objects behave helps you explain performance when using static-like features in Kotlin.

Self-Check

"What if we replaced the companion object function with an inline function? How would the time complexity change?"

Practice

1. What is the main purpose of a companion object in a Kotlin class?

easy

A. To hold static-like members accessible without creating an instance

B. To create multiple instances of a class

C. To inherit properties from another class

D. To define instance variables for each object

Solution

1. Step 1: Understand companion object role

   Companion objects allow defining members that belong to the class itself, not to instances.

2. Step 2: Compare with instance members

   Instance variables belong to objects, but companion object members behave like static members accessible via the class name.

3. Final Answer:

   To hold static-like members accessible without creating an instance -> Option A

4. Quick Check:

   Companion object = static-like members [OK]

Hint: Companion objects act like static members in Kotlin classes [OK]

Common Mistakes:

• Thinking companion objects create instances
• Confusing companion objects with inheritance
• Assuming companion objects hold instance variables

2. Which of the following is the correct syntax to declare a companion object inside a Kotlin class?

easy

A. object companion { val x = 10 }

B. companion object { val x = 10 }

C. static object { val x = 10 }

D. class companion { val x = 10 }

Solution

1. Step 1: Recall Kotlin companion object syntax

   The correct keyword order is companion object inside the class.

2. Step 2: Check each option

   companion object { val x = 10 } uses the correct syntax. Options A, B, and D use incorrect keywords or order.

3. Final Answer:

   companion object { val x = 10 } -> Option B

4. Quick Check:

   companion object syntax = companion object { val x = 10 } [OK]

Hint: Remember: 'companion object' keyword order is fixed [OK]

Common Mistakes:

• Using 'static' keyword which Kotlin does not have
• Swapping 'object' and 'companion' keywords
• Declaring companion as a class

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

class MyClass {
    companion object {
        val number = 42
        fun greet() = "Hello"
    }
}

fun main() {
    println(MyClass.number)
    println(MyClass.greet())
}

medium

A. null\nnull

B. number\ngreet

C. Compilation error

D. 42\nHello

Solution

1. Step 1: Understand companion object access

   Members inside companion object can be accessed using the class name without creating an instance.

2. Step 2: Evaluate the print statements

   Printing MyClass.number outputs 42, and MyClass.greet() outputs "Hello".

3. Final Answer:

   42\nHello -> Option D

4. Quick Check:

   Companion members accessed via class name = 42 and Hello [OK]

Hint: Access companion members with ClassName.member [OK]

Common Mistakes:

• Trying to create an instance to access companion members
• Expecting compilation error due to missing instance
• Confusing companion members with instance members

4. Identify the error in the following Kotlin code using companion objects:

class Example {
    companion object {
        fun show() = println("Show called")
    }
}

fun main() {
    val e = Example()
    e.show()
}

medium

A. Function show() must return a value

B. Missing companion object keyword

C. Cannot call companion object function on instance

D. Class Example cannot have companion objects

Solution

1. Step 1: Analyze how companion functions are accessed

   Functions inside companion objects are accessed via the class name, not instances.

2. Step 2: Check the call e.show()

   Calling show() on instance e causes an error because show() is not an instance method.

3. Final Answer:

   Cannot call companion object function on instance -> Option C

4. Quick Check:

   Companion functions accessed via class, not instance [OK]

Hint: Call companion functions with ClassName.function(), not instance [OK]

Common Mistakes:

• Calling companion functions on instances
• Forgetting companion object keyword
• Expecting companion functions to be instance methods

5. You want to create a Kotlin class Calculator with a companion object that provides a static method add to add two integers. Which code snippet correctly implements this and allows calling Calculator.add(5, 3) without creating an instance?

hard

A. class Calculator {
companion object {
fun add(a: Int, b: Int) = a + b
}
}

B. class Calculator {
fun add(a: Int, b: Int) = a + b
}

C. object Calculator {
fun add(a: Int, b: Int) = a + b
}

D. class Calculator {
static fun add(a: Int, b: Int) = a + b
}

Solution

1. Step 1: Identify correct static-like method declaration

   In Kotlin, static methods are created inside companion objects.

2. Step 2: Evaluate each option

   class Calculator { companion object { fun add(a: Int, b: Int) = a + b } } correctly defines add inside a companion object. class Calculator { fun add(a: Int, b: Int) = a + b } defines an instance method, so requires an object. object Calculator { fun add(a: Int, b: Int) = a + b } uses an object declaration, which works but is not a companion object inside a class. class Calculator { static fun add(a: Int, b: Int) = a + b } uses 'static' keyword which Kotlin does not support.

3. Final Answer:

   class Calculator { companion object { fun add(a: Int, b: Int) = a + b } } -> Option A

4. Quick Check:

   Companion object method = class Calculator { companion object { fun add(a: Int, b: Int) = a + b } } [OK]

Hint: Use companion object for static methods inside classes [OK]

Common Mistakes:

• Using 'static' keyword which Kotlin lacks
• Defining method outside companion object
• Using object declaration instead of companion object