Why object declarations create singletons in Kotlin - Visual Breakdown

Concept Flow - Why object declarations create singletons

Start program

↓

Declare object

↓

Object instance created once

↓

Access object multiple times

↓

Same instance used every time

↓

Program ends

The program declares an object which creates a single instance. Every access uses this same instance, ensuring only one exists.

Execution Sample

Kotlin

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

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

This code declares a singleton object Logger and calls its log function twice, using the same instance.

Execution Table

Step	Action	Evaluation	Result
1	Program starts	No object instance yet	No instance created
2	Object Logger declared	Object declaration does not immediately create instance	Instance created at first access
3	Call Logger.log("Start")	Instance created at first access, then used	Prints: Log: Start
4	Call Logger.log("End")	Use same Logger instance	Prints: Log: End
5	Program ends	No new instances created	Only one Logger instance used

💡 Program ends after using the single Logger instance multiple times

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
Logger instance	null	null	created	used	used

Key Moments - 3 Insights

Why is the Logger instance created only once?

Because object declarations in Kotlin create a singleton instance at first access, as shown in execution_table step 3.

Does calling Logger.log create a new Logger instance each time?

No, the same Logger instance is reused every time, as shown in steps 3 and 4 of the execution_table.

What if we declare Logger as a class instead of object?

Then each time we create Logger(), a new instance is made. But with object, Kotlin ensures only one instance exists.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the Logger instance created?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Check the 'Result' column in execution_table row for Step 3

According to variable_tracker, what is the state of Logger instance after Step 4?

A null

B created

C used

D destroyed

💡 Hint

Look at the 'Logger instance' row and the 'After Step 4' column in variable_tracker

If Logger was declared as a class, how would the execution_table change?

A Instance created at every call to log()

B Instance created once at Step 2

C No instance created

D Instance created only at program end

💡 Hint

Recall that class declarations create new instances on each constructor call, unlike object declarations

Concept Snapshot

Kotlin object declarations create a singleton instance.
This instance is created once at first access.
All uses share the same instance.
Use object for single-instance utilities.
Unlike classes, no new instances are made on usage.

Full Transcript

In Kotlin, when you declare an object, the system creates exactly one instance of it. This instance is made the first time the object is accessed. Every time you use the object later, you get the same instance. For example, the Logger object is created once when the program starts. When Logger.log is called twice, both calls use the same Logger instance. This is different from classes, where each new object is a new instance. Objects are useful when you want a single shared instance, like for logging or configuration.