Object declaration syntax in Kotlin - Interactive Code Practice

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 the object.

Forgetting to use the object keyword.

The keyword object declares a singleton object named Logger.

2fill in blank

medium

Complete the code to call the log function of the Logger object.

Kotlin

fun main() {
    [1].log("Hello, Kotlin!")
}

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

ALogger

BLogObject

Clogger

DLog

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase or incorrect object names.

Trying to create an instance instead of using the object directly.

To call the log function, use the object name Logger.

3fill in blank

hard

Fix the error in the object declaration syntax.

Kotlin

object [1] {
    fun greet() = println("Hi!")
}

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

Agreeter

BGreeter

CGreeterObject

DGreeter()

Attempts:

3 left

💡 Hint

Common Mistakes

Adding parentheses after the object name.

Using lowercase names for objects.

Object declarations do not use parentheses. Remove them and use a valid name like Greeter.

4fill in blank

hard

Fill both blanks to declare an object with a property and a function.

Kotlin

object [1] {
    val [2] = "Kotlin"
    fun printName() = println(name)
}

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

AAppConfig

BappName

Cname

DConfig

Attempts:

3 left

💡 Hint

Common Mistakes

Mismatch between property name and usage in function.

Using lowercase object names.

The object is named AppConfig and the property used in the function is name.

5fill in blank

hard

Fill all three blanks to create an object with a mutable property and a function to update it.

Kotlin

object [1] {
    var [2] = 0
    fun [3](value: Int) {
        count = value
    }
}

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

ACounter

Bcount

CupdateCount

Dcounter

Attempts:

3 left

💡 Hint

Common Mistakes

Using immutable property val instead of var.

Mismatch between property and function parameter names.

The object is Counter, the mutable property is count, and the function to update it is updateCount.

Practice

1. What does the object keyword in Kotlin do?

easy

A. Creates a function that returns an object

B. Defines a class that can be instantiated multiple times

C. Declares a variable of type Object

D. Creates a single instance with properties and functions

Solution

1. Step 1: Understand the object keyword purpose

   The object keyword creates a singleton, meaning one single instance with properties and functions.

2. Step 2: Compare with other options

   Classes can be instantiated multiple times, variables don't define singletons, and functions returning objects are different concepts.

3. Final Answer:

   Creates a single instance with properties and functions -> Option D

4. Quick Check:

   object keyword = single instance [OK]

Hint: Remember: object = one single instance [OK]

Common Mistakes:

• Confusing object with class
• Thinking object creates multiple instances
• Mixing object with variable declaration

2. Which of the following is the correct syntax to declare an object named Config in Kotlin?

easy

A. object Config { }

B. val Config = object { }

C. class Config { }

D. fun Config() { }

Solution

1. Step 1: Identify the object declaration syntax

   The correct syntax to declare a singleton object is using the object keyword followed by the name and curly braces.

2. Step 2: Check other options

   class Config { } declares a class, B declares an anonymous object assigned to a val, and D declares a function, so they are incorrect.

3. Final Answer:

   object Config { } -> Option A

4. Quick Check:

   object keyword + name + braces = correct syntax [OK]

Hint: Use 'object Name { }' to declare singleton objects [OK]

Common Mistakes:

• Using class instead of object
• Assigning anonymous object to val instead
• Using function syntax by mistake

3. What is the output of this Kotlin code?

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

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

medium

A. Log: Start

B. Start

C. Logger.log(Start)

D. Compilation error

Solution

1. Step 1: Understand object usage

   The object Logger has a function log that prints "Log: " plus the message.

2. Step 2: Trace the main function call

   Calling Logger.log("Start") prints "Log: Start" to the console.

3. Final Answer:

   Log: Start -> Option A

4. Quick Check:

   Logger.log("Start") prints "Log: Start" [OK]

Hint: Object functions called by object name print their output [OK]

Common Mistakes:

• Expecting just the message without prefix
• Thinking it prints the function call text
• Assuming compilation error due to object usage

4. Identify the error in this Kotlin object declaration:

object Data {
    var count: Int
    fun increment() {
        count++
    }
}

medium

A. Cannot use 'var' inside object

B. Missing initialization for 'count' property

C. Function 'increment' should return Int

D. Object cannot have properties

Solution

1. Step 1: Check property declaration

   The property 'count' is declared but not initialized or marked as abstract, which is invalid in objects.

2. Step 2: Validate other options

   Objects can have vars, functions can be Unit-returning, and objects can have properties, so other options are incorrect.

3. Final Answer:

   Missing initialization for 'count' property -> Option B

4. Quick Check:

   Properties in objects must be initialized [OK]

Hint: Always initialize properties in objects or use lateinit [OK]

Common Mistakes:

• Forgetting to initialize properties
• Thinking vars are disallowed in objects
• Expecting functions to always return a value

5. You want to create a singleton object Cache that stores key-value pairs and provides a function getValue(key: String): String?. Which of the following is the best Kotlin object declaration?

hard

A. fun Cache() = mutableMapOf()
fun getValue(key: String) = Cache()[key]

B. class Cache {
val map = mutableMapOf()
fun getValue(key: String) = map[key]
}

C. object Cache {
private val map = mutableMapOf()
fun getValue(key: String) = map[key]
}

D. val Cache = mapOf()
fun getValue(key: String) = Cache[key]

Solution

1. Step 1: Identify singleton pattern

   Using object creates a singleton Cache with a private mutable map and a function to get values.

2. Step 2: Compare other options

   class Cache { val map = mutableMapOf() fun getValue(key: String) = map[key] } is a class needing instances, C is a function returning a new map each time, D uses an immutable map and separate function, not encapsulated.

3. Final Answer:

   object Cache { private val map = mutableMapOf() fun getValue(key: String) = map[key] } -> Option C

4. Quick Check:

   Singleton object with private mutable map = object Cache { private val map = mutableMapOf() fun getValue(key: String) = map[key] } [OK]

Hint: Use object with private mutable map for singleton cache [OK]

Common Mistakes:

• Using class instead of object for singleton
• Returning new map each call instead of storing
• Using immutable map when mutation is needed