Companion vs top-level functions decision in Kotlin - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of companion object function call

What is the output of this Kotlin code when calling MyClass.greet()?

Kotlin

class MyClass {
    companion object {
        fun greet() = "Hello from companion"
    }
}

fun main() {
    println(MyClass.greet())
}

A Hello from companion

B Compilation error: greet is not a member of MyClass

C Hello from top-level function

D Runtime error: Unresolved reference greet

💡 Hint

Companion object functions can be called using the class name.

The function greet() is inside the companion object of MyClass, so it can be called as MyClass.greet(). This prints the string returned by greet().

🧠 Conceptual

intermediate

Choosing between companion and top-level functions

Which situation is best suited for using a companion object function instead of a top-level function in Kotlin?

A When you want to define a function that can be called without importing

B When the function is a utility unrelated to any class

C When you want to avoid creating any class in your code

D When the function logically belongs to a class and needs access to its private members

💡 Hint

Think about encapsulation and access to class internals.

Companion object functions can access private members of their class, so they are suitable when the function logically belongs to the class and needs such access. Top-level functions are better for unrelated utilities.

❓ Predict Output

advanced

Output of top-level vs companion function with same name

What is the output of this Kotlin code?

Kotlin

fun greet() = "Hello from top-level"

class MyClass {
    companion object {
        fun greet() = "Hello from companion"
    }
}

fun main() {
    println(greet())
    println(MyClass.greet())
}

A Compilation error: greet is ambiguous

B

Hello from top-level
Hello from companion

C

Hello from companion
Hello from top-level

D Runtime error: greet not found

💡 Hint

Top-level and companion functions with the same name are called differently.

The top-level greet() is called directly, printing "Hello from top-level". The companion greet() is called with MyClass.greet(), printing "Hello from companion".

🔧 Debug

advanced

Why does this companion object function cause a compilation error?

Consider this Kotlin code snippet: class MyClass { companion object { fun printMessage() { println(message) } } private val message = "Hello" } Why does this code cause a compilation error?

A Companion object cannot access instance properties like 'message'

B The 'message' property is not initialized

C The function printMessage must be marked as static

D The companion object must be named explicitly

💡 Hint

Think about what companion objects can access inside a class.

Companion objects are like static members and cannot access instance properties directly. 'message' is an instance property, so the companion object function cannot access it.

🧠 Conceptual

expert

Best practice for organizing utility functions in Kotlin

You have several utility functions that do not require access to any class members. What is the best practice for organizing these functions in Kotlin?

A Place them inside an object declaration to simulate static methods

B Place them inside a companion object of a class

C Place them as top-level functions in a Kotlin file

D Place them as member functions inside a class instance

💡 Hint

Consider simplicity and idiomatic Kotlin style.

Top-level functions are the idiomatic way in Kotlin to define utility functions that do not need class context. Companion objects or object declarations are used when grouping related functions or needing static-like behavior.