Companion objects as static alternatives in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of companion object property access

What is the output of this Kotlin code?

Kotlin

class Example {
    companion object {
        val greeting = "Hello, Kotlin!"
    }
}

fun main() {
    println(Example.greeting)
}

A null

B Compilation error: Cannot access companion object property directly

C Hello, Kotlin!

D Runtime exception

💡 Hint

Companion object properties can be accessed using the class name.

In Kotlin, companion object members can be accessed directly via the class name without creating an instance.

❓ Predict Output

intermediate

Calling companion object function

What will this Kotlin program print?

Kotlin

class Calculator {
    companion object {
        fun add(a: Int, b: Int) = a + b
    }
}

fun main() {
    println(Calculator.add(5, 7))
}

A 12

B Compilation error: Cannot call companion object function like this

C 0

D Runtime exception

💡 Hint

Companion object functions behave like static methods.

The add function inside the companion object can be called using the class name without creating an instance.

🔧 Debug

advanced

Why does this companion object code fail?

This Kotlin code produces a compilation error. What is the cause?

Kotlin

class Person {
    companion object {
        val name: String
    }

    init {
        name = "Alice"
    }
}

fun main() {
    println(Person.name)
}

A Cannot access companion object property from init block

B The init block cannot assign values to companion object properties

C Companion object cannot have properties

D Property 'name' in companion object must be initialized or declared abstract

💡 Hint

Companion object properties need initialization at declaration or in an init block inside the companion object.

The property 'name' in the companion object is declared but not initialized. Kotlin requires properties in companion objects to be initialized or abstract.

🧠 Conceptual

advanced

Companion object vs static in Kotlin

Which statement correctly describes the difference between Kotlin companion objects and Java static members?

A Companion objects are compiled as static members in Java bytecode with no object instance.

B Companion objects are real objects and can implement interfaces, unlike Java static members.

C Companion objects cannot have functions, only properties.

D Companion objects are only accessible through instances of the class.

💡 Hint

Think about how companion objects behave as objects themselves.

Companion objects are singleton objects inside a class and can implement interfaces, have their own state, and be passed around as objects, unlike static members in Java.

❓ Predict Output

expert

Output of companion object with private constructor

What is the output of this Kotlin program?

Kotlin

class Secret private constructor(val code: Int) {
    companion object {
        fun create(code: Int): Secret = Secret(code)
    }
}

fun main() {
    val secret = Secret.create(42)
    println(secret.code)
}

A 42

B Compilation error: Cannot access private constructor

C Runtime exception

D null

💡 Hint

Companion objects can access private constructors of their class.

The companion object is part of the class and can call private constructors. The create function returns an instance with code 42.

Practice

1. What is the main purpose of a companion object in a Kotlin class?

easy

A. To hold static-like members accessible without creating an instance

B. To create multiple instances of a class

C. To inherit properties from another class

D. To define instance variables for each object

Solution

1. Step 1: Understand companion object role

   Companion objects allow defining members that belong to the class itself, not to instances.

2. Step 2: Compare with instance members

   Instance variables belong to objects, but companion object members behave like static members accessible via the class name.

3. Final Answer:

   To hold static-like members accessible without creating an instance -> Option A

4. Quick Check:

   Companion object = static-like members [OK]

Hint: Companion objects act like static members in Kotlin classes [OK]

Common Mistakes:

• Thinking companion objects create instances
• Confusing companion objects with inheritance
• Assuming companion objects hold instance variables

2. Which of the following is the correct syntax to declare a companion object inside a Kotlin class?

easy

A. object companion { val x = 10 }

B. companion object { val x = 10 }

C. static object { val x = 10 }

D. class companion { val x = 10 }

Solution

1. Step 1: Recall Kotlin companion object syntax

   The correct keyword order is companion object inside the class.

2. Step 2: Check each option

   companion object { val x = 10 } uses the correct syntax. Options A, B, and D use incorrect keywords or order.

3. Final Answer:

   companion object { val x = 10 } -> Option B

4. Quick Check:

   companion object syntax = companion object { val x = 10 } [OK]

Hint: Remember: 'companion object' keyword order is fixed [OK]

Common Mistakes:

• Using 'static' keyword which Kotlin does not have
• Swapping 'object' and 'companion' keywords
• Declaring companion as a class

3. What will be the output of the following Kotlin code?

class MyClass {
    companion object {
        val number = 42
        fun greet() = "Hello"
    }
}

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

medium

A. null\nnull

B. number\ngreet

C. Compilation error

D. 42\nHello

Solution

1. Step 1: Understand companion object access

   Members inside companion object can be accessed using the class name without creating an instance.

2. Step 2: Evaluate the print statements

   Printing MyClass.number outputs 42, and MyClass.greet() outputs "Hello".

3. Final Answer:

   42\nHello -> Option D

4. Quick Check:

   Companion members accessed via class name = 42 and Hello [OK]

Hint: Access companion members with ClassName.member [OK]

Common Mistakes:

• Trying to create an instance to access companion members
• Expecting compilation error due to missing instance
• Confusing companion members with instance members

4. Identify the error in the following Kotlin code using companion objects:

class Example {
    companion object {
        fun show() = println("Show called")
    }
}

fun main() {
    val e = Example()
    e.show()
}

medium

A. Function show() must return a value

B. Missing companion object keyword

C. Cannot call companion object function on instance

D. Class Example cannot have companion objects

Solution

1. Step 1: Analyze how companion functions are accessed

   Functions inside companion objects are accessed via the class name, not instances.

2. Step 2: Check the call e.show()

   Calling show() on instance e causes an error because show() is not an instance method.

3. Final Answer:

   Cannot call companion object function on instance -> Option C

4. Quick Check:

   Companion functions accessed via class, not instance [OK]

Hint: Call companion functions with ClassName.function(), not instance [OK]

Common Mistakes:

• Calling companion functions on instances
• Forgetting companion object keyword
• Expecting companion functions to be instance methods

5. You want to create a Kotlin class Calculator with a companion object that provides a static method add to add two integers. Which code snippet correctly implements this and allows calling Calculator.add(5, 3) without creating an instance?

hard

A. class Calculator {
companion object {
fun add(a: Int, b: Int) = a + b
}
}

B. class Calculator {
fun add(a: Int, b: Int) = a + b
}

C. object Calculator {
fun add(a: Int, b: Int) = a + b
}

D. class Calculator {
static fun add(a: Int, b: Int) = a + b
}

Solution

1. Step 1: Identify correct static-like method declaration

   In Kotlin, static methods are created inside companion objects.

2. Step 2: Evaluate each option

   class Calculator { companion object { fun add(a: Int, b: Int) = a + b } } correctly defines add inside a companion object. class Calculator { fun add(a: Int, b: Int) = a + b } defines an instance method, so requires an object. object Calculator { fun add(a: Int, b: Int) = a + b } uses an object declaration, which works but is not a companion object inside a class. class Calculator { static fun add(a: Int, b: Int) = a + b } uses 'static' keyword which Kotlin does not support.

3. Final Answer:

   class Calculator { companion object { fun add(a: Int, b: Int) = a + b } } -> Option A

4. Quick Check:

   Companion object method = class Calculator { companion object { fun add(a: Int, b: Int) = a + b } } [OK]

Hint: Use companion object for static methods inside classes [OK]

Common Mistakes:

• Using 'static' keyword which Kotlin lacks
• Defining method outside companion object
• Using object declaration instead of companion object