Why object declarations create singletons in Kotlin - See It in Action

Why object declarations create singletons

📖 Scenario: Imagine you want to have a single shared resource in your Kotlin program, like a single printer manager that everyone uses. Kotlin's object declaration helps you create such a single shared instance easily.

🎯 Goal: You will create an object declaration in Kotlin and see how it acts as a singleton by accessing it multiple times and confirming it is the same instance.

📋 What You'll Learn

Create an object called PrinterManager with a function printMessage() that prints a message.

Create two variables firstAccess and secondAccess that refer to PrinterManager.

Compare firstAccess and secondAccess to confirm they point to the same instance.

Print the result of the comparison.

💡 Why This Matters

🌍 Real World

Singletons are used in apps to manage shared resources like printers, database connections, or configuration settings where only one instance should exist.

💼 Career

Understanding Kotlin's <code>object</code> singleton pattern is important for Android developers and backend Kotlin programmers to write clean, efficient, and safe code.

1

Create the object declaration

Create an object called PrinterManager with a function printMessage() that prints the text "Printing a document...".

Kotlin

# Your code here

Hint

Use object PrinterManager to declare a singleton object. Inside it, define fun printMessage() that calls println.

2

Access the object twice

Create two variables firstAccess and secondAccess and assign both to PrinterManager.

Kotlin

object PrinterManager {
    fun printMessage() {
        println("Printing a document...")
    }
}

# Your code here

Hint

Assign PrinterManager to both firstAccess and secondAccess variables.

3

Compare the two references

Create a variable areSameInstance that stores the result of comparing firstAccess and secondAccess using ===.

Kotlin

object PrinterManager {
    fun printMessage() {
        println("Printing a document...")
    }
}

val firstAccess = PrinterManager
val secondAccess = PrinterManager

# Your code here

Hint

Use === to check if both variables point to the same object instance.

4

Print the comparison result

Print the value of areSameInstance.

Kotlin

object PrinterManager {
    fun printMessage() {
        println("Printing a document...")
    }
}

val firstAccess = PrinterManager
val secondAccess = PrinterManager

val areSameInstance = firstAccess === secondAccess

# Your code here

Hint

Use println(areSameInstance) to show if both references are the same object.

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