Why object declarations create singletons in Kotlin - Performance Analysis

Time Complexity: Why object declarations create singletons

O(n)

Understanding Time Complexity

Let's explore how Kotlin's object declarations behave when creating singletons.

We want to understand how the cost of creating and accessing these objects changes as the program runs.

Scenario Under Consideration

Analyze the time complexity of this Kotlin object declaration and its usage.

object Logger {
    fun log(message: String) {
        println(message)
    }
}

fun main() {
    Logger.log("Start")
    Logger.log("End")
}
    

This code defines a singleton Logger object and calls its log function twice.

Identify Repeating Operations

Look for repeated actions or object creations.

• Primary operation: Calling Logger.log() twice.
• How many times: Twice in this example, but could be many times in a real program.
• Object creation: Happens only once when Logger is first accessed.

How Execution Grows With Input

Each call to Logger.log() runs a simple print operation.

Input Size (number of calls)	Approx. Operations
10	10 print calls, 1 object creation
100	100 print calls, 1 object creation
1000	1000 print calls, 1 object creation

Notice the object is created only once, no matter how many times we call log().

Final Time Complexity

Time Complexity: O(n)

This means the total time grows linearly with the number of log calls, but the object creation cost stays constant.

Common Mistake

[X] Wrong: "The Logger object is created every time we call log()."

[OK] Correct: Kotlin creates the object only once when first used, so repeated calls reuse the same instance.

Interview Connect

Understanding how Kotlin manages object declarations helps you explain efficient resource use and singleton patterns clearly.

Self-Check

What if we replaced the object declaration with a class and created a new instance each time? How would the time complexity change?

Practice

1. Why does an object declaration in Kotlin create a singleton?

easy

A. Because it cannot hold any properties or functions

B. Because it allows multiple instances to be created

C. Because it is the same as a class with a constructor

D. Because it creates only one instance automatically and shares it everywhere

Solution

1. Step 1: Understand object declaration behavior

   An object declaration creates a single instance automatically without needing to call a constructor.

2. Step 2: Recognize singleton sharing

   This single instance is shared everywhere in the program, ensuring only one copy exists.

3. Final Answer:

   Because it creates only one instance automatically and shares it everywhere -> Option D

4. Quick Check:

   Singleton = single shared instance [OK]

Hint: Object declarations create one shared instance automatically [OK]

Common Mistakes:

• Thinking object creates multiple instances
• Confusing object with regular class
• Assuming object cannot have properties

2. Which of the following is the correct syntax to declare a singleton object in Kotlin?

easy

A. object MySingleton { fun greet() = "Hello" }

B. class MySingleton() { fun greet() = "Hello" }

C. singleton MySingleton { fun greet() = "Hello" }

D. object MySingleton() { fun greet() = "Hello" }

Solution

1. Step 1: Identify correct object declaration syntax

   In Kotlin, object declarations do not use parentheses; they are declared as object Name { ... }.

2. Step 2: Check options for syntax errors

   object MySingleton { fun greet() = "Hello" } uses correct syntax without parentheses. object MySingleton() { fun greet() = "Hello" } incorrectly uses parentheses. Options B and C use invalid keywords or class syntax.

3. Final Answer:

   object MySingleton { fun greet() = "Hello" } -> Option A

4. Quick Check:

   Object declaration syntax = object Name { } [OK]

Hint: Object declarations never have parentheses after the name [OK]

Common Mistakes:

• Adding parentheses after object name
• Using class keyword instead of object
• Using non-existent singleton keyword

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

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

fun main() {
    Counter.increment()
    Counter.increment()
    println(Counter.count)
}

medium

A. 0

B. 1

C. 2

D. Compilation error

Solution

1. Step 1: Understand the singleton object usage

   The Counter object holds a single count variable shared everywhere. Calling increment() increases count by 1 each time.

2. Step 2: Trace the increments and print

   Two calls to increment() increase count from 0 to 2. Printing Counter.count outputs 2.

3. Final Answer:

   2 -> Option C

4. Quick Check:

   2 increments = count 2 [OK]

Hint: Object properties keep state shared across calls [OK]

Common Mistakes:

• Assuming count resets each call
• Thinking increment returns a value
• Confusing object with class instance

4. This Kotlin code tries to create two instances of an object. What is the error?

object Logger {
    fun log(msg: String) = println(msg)
}

fun main() {
    val log1 = Logger()
    val log2 = Logger()
    log1.log("Test")
}

medium

A. log1 and log2 are null

B. Cannot create instances of an object; it has no constructor

C. Logger object is missing a constructor

D. No error; code runs fine

Solution

1. Step 1: Understand object instantiation rules

   In Kotlin, object declarations cannot be instantiated with parentheses because they have no constructor and are singletons.

2. Step 2: Identify the error in code

   Trying to call Logger() causes a compilation error because object cannot be instantiated.

3. Final Answer:

   Cannot create instances of an object; it has no constructor -> Option B

4. Quick Check:

   Object cannot be instantiated = error [OK]

Hint: Objects have no constructors; don't use parentheses [OK]

Common Mistakes:

• Trying to instantiate object with ()
• Assuming object needs constructor
• Ignoring compilation errors

5. You want to count how many times a function is called across your entire Kotlin program. Which approach using an object declaration is best?

hard

A. Declare an object with a mutable counter property and increment it inside the function

B. Declare a class with a counter property and create a new instance each call

C. Use a local variable inside the function to count calls

D. Declare an object with a constant counter property initialized to zero

Solution

1. Step 1: Identify need for shared mutable state

   Counting calls across the program requires a shared variable that updates each time the function runs.

2. Step 2: Choose object with mutable property

   An object with a mutable counter property can be accessed and incremented from anywhere, preserving state.

3. Step 3: Evaluate other options

   Creating new class instances each call resets count. Local variables reset each call. Constant properties cannot change.

4. Final Answer:

   Declare an object with a mutable counter property and increment it inside the function -> Option A

5. Quick Check:

   Singleton object with mutable state counts calls [OK]

Hint: Use object with var property to share and update count [OK]

Common Mistakes:

• Using class instances that reset count
• Using val instead of var for counter
• Counting inside local function variable