Why object declarations create singletons in Kotlin - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a singleton object named Logger.

Kotlin

object [1] {
    fun log(message: String) {
        println(message)
    }
}

Drag options to blanks, or click blank then click option'

Alogger

BLog

CLogger

DLogObject

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase names for object declarations.

Trying to declare an object with class keyword.

The keyword object followed by the name Logger declares a singleton object in Kotlin.

2fill in blank

medium

Complete the code to call the log function on the singleton object.

Kotlin

fun main() {
    [1].log("Hello Singleton")
}

Drag options to blanks, or click blank then click option'

ALogger

BLogger()

Cnew Logger()

Dlogger

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to create an instance with parentheses.

Using lowercase name that does not match the object.

Singleton objects are accessed by their name directly without parentheses.

3fill in blank

hard

Fix the error in the code to ensure only one instance of the object is used.

Kotlin

val logger1 = [1]
val logger2 = Logger
println(logger1 === logger2)

Drag options to blanks, or click blank then click option'

ALogger()

Blogger

Cnew Logger()

DLogger

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses to create new instances.

Using lowercase names that do not match the object.

Singleton objects in Kotlin do not use parentheses. Using Logger accesses the single instance.

4fill in blank

hard

Fill both blanks to create a singleton object with a property and access it.

Kotlin

object [1] {
    val version = [2]
}
fun main() {
    println(AppInfo.version)
}

Drag options to blanks, or click blank then click option'

AAppInfo

B"1.0"

C1.0

DVersion

Attempts:

3 left

💡 Hint

Common Mistakes

Using a number without quotes for a string property.

Using lowercase or incorrect object names.

The object name is AppInfo and the property version is a string "1.0".

5fill in blank

hard

Fill all three blanks to define a singleton object with a function and call it.

Kotlin

object [1] {
    fun greet(name: String) = "Hello, [2]!"
}
fun main() {
    println(Greeter.greet([3]))
}

Drag options to blanks, or click blank then click option'

AGreeter

B$name

C"Alice"

Dname

Attempts:

3 left

💡 Hint

Common Mistakes

Using \$name instead of $name for string interpolation.

Passing a variable name instead of a string literal.

The object is named Greeter. The function uses string interpolation with $name. The call passes the string "Alice".

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