Companion objects as static alternatives in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a companion object in Kotlin?

A companion object is a special object inside a class that allows you to define members which behave like static members in Java. It belongs to the class, not to instances.

beginner

How do you declare a companion object inside a Kotlin class?

Use the keyword <code>companion object</code> inside the class. For example:<br><pre>class MyClass {
  companion object {
    val constant = 42
  }
}</pre>

beginner

Why use companion objects instead of static members in Kotlin?

Kotlin does not have static members. Companion objects provide a way to have class-level members that can be accessed without creating an instance, similar to static in Java.

beginner

How do you access a member inside a companion object?

You access it using the class name, like <code>MyClass.constant</code>. You don't need to create an instance of the class.

intermediate

Can a companion object implement interfaces in Kotlin?

Yes, a companion object can implement interfaces, allowing it to have behavior and be passed around as an object.

What keyword is used to declare a companion object in Kotlin?

A companion object

B static

C object static

D class companion

In Kotlin, the keyword companion object declares a companion object inside a class.

How do you access a property named count inside a companion object of class Counter?

A Counter.count

B count.Counter

C Counter().count

D companion.count

Members of a companion object are accessed using the class name, like Counter.count.

Which of these is true about companion objects?

A They are the same as Java static methods

B They are created for each instance

C They cannot have functions

D They belong to the class, not instances

Companion objects belong to the class and are shared, unlike instance members.

Can a companion object implement an interface?

A No

B Yes

C Only if the class implements it

D Only in Java

Companion objects can implement interfaces to provide behavior.

Why does Kotlin use companion objects instead of static members?

A Static members are deprecated

B Companion objects are faster

C Kotlin does not support static members

D Companion objects are only for constants

Kotlin does not have static members; companion objects provide a similar feature.

Explain what a companion object is and how it acts as a static alternative in Kotlin.

Think about how you would use static members in Java.

Describe how to declare and access a property inside a companion object.

Remember the keyword and how you call it.

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