Named companion objects 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 call its members like static members in other languages. It is created once per class and can hold functions and properties.

intermediate

Why would you use a named companion object instead of the default unnamed one?

You use a named companion object to give it a specific name, which can improve code readability and allow you to implement interfaces or distinguish between multiple companion objects if needed.

beginner

How do you declare a named companion object in Kotlin?

Inside a class, write `companion object Name { ... }` where `Name` is the chosen name for the companion object.

intermediate

Can you access members of a named companion object without specifying the name?

Yes, Kotlin allows you to access members of the companion object directly through the class name without using the companion object's name, but you can also use the name explicitly if you want.

intermediate

What is a practical example of using a named companion object?

A named companion object can implement an interface or hold factory methods with a clear name, making the code easier to understand and organize.

How do you declare a named companion object in Kotlin?

A companion object Name { }

B object companion Name { }

C companion Name object { }

D object Name companion { }

The correct syntax is 'companion object Name { }' where 'Name' is the name you give to the companion object.

What is the main benefit of naming a companion object?

A To create multiple companion objects with the same name

B To improve code readability and allow interface implementation

C To prevent access from outside the class

D To make the companion object private

Naming a companion object helps with readability and allows it to implement interfaces or be referenced explicitly.

Can you access a named companion object's members without using its name?

A Only if the companion object is private

B No, you must always use the companion object's name

C Only if the companion object is unnamed

D Yes, through the class name directly

Kotlin lets you access companion object members directly via the class name, even if the companion object has a name.

Which of these is NOT true about companion objects?

A They can be instantiated multiple times

B They can hold functions and properties

C They are created once per class

D They can implement interfaces

Companion objects are singletons per class and cannot be instantiated multiple times.

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

A object

B static

C companion

D class

The keyword 'companion' is used to declare a companion object inside a class.

Explain what a named companion object is and why you might use one in Kotlin.

Think about how naming helps organize code and implement interfaces.

Describe how to declare and access members of a named companion object with a simple example.

Write a small code snippet in your mind or on paper.

Practice

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

easy

A. To give a clear and specific name to the singleton object inside a class

B. To create multiple instances of the companion object

C. To make the companion object inherit from another class

D. To prevent the companion object from being accessed outside the class

Solution

1. Step 1: Understand companion objects

   Companion objects are singletons inside a class used to hold members related to the class itself.

2. Step 2: Purpose of naming companion objects

   Giving a name to a companion object helps to clearly identify and access its members, improving code readability.

3. Final Answer:

   To give a clear and specific name to the singleton object inside a class -> Option A

4. Quick Check:

   Named companion object = clear singleton name [OK]

Hint: Named companion objects clarify singleton usage [OK]

Common Mistakes:

• Thinking companion objects create multiple instances
• Confusing naming with inheritance
• Assuming naming restricts access

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

easy

A. class MyClass { companionobject Named { fun greet() = "Hi" } }

B. class MyClass { companion Named object { fun greet() = "Hi" } }

C. class MyClass { companion object Named { fun greet() = "Hi" } }

D. class MyClass { object companion Named { fun greet() = "Hi" } }

Solution

1. Step 1: Recall correct companion object syntax

   The correct syntax is 'companion object Name { ... }' inside the class.

2. Step 2: Check each option

   class MyClass { companion object Named { fun greet() = "Hi" } } matches the correct syntax exactly. Others have misplaced keywords or wrong order.

3. Final Answer:

   class MyClass { companion object Named { fun greet() = "Hi" } } -> Option C

4. Quick Check:

   companion object Name { } syntax [OK]

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

Common Mistakes:

• Swapping 'object' and 'companion' keywords
• Writing 'companionobject' as one word
• Placing the name before 'companion'

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

class Box {
    companion object Factory {
        fun create() = "Box created"
    }
}
fun main() {
    println(Box.Factory.create())
}

medium

A. Factory created

B. Box created

C. Compilation error

D. Runtime exception

Solution

1. Step 1: Understand named companion object usage

   The companion object named 'Factory' holds the function 'create' which returns "Box created".

2. Step 2: Analyze the main function call

   Calling 'Box.Factory.create()' accesses the named companion object and calls 'create', printing "Box created".

3. Final Answer:

   Box created -> Option B

4. Quick Check:

   Box.Factory.create() prints "Box created" [OK]

Hint: Call named companion with ClassName.Name.method() [OK]

Common Mistakes:

• Trying to call create() without Factory prefix
• Expecting 'Factory created' output
• Confusing syntax causing compile errors

4. Identify the error in this Kotlin code snippet:

class Sample {
    companion object Companion {
        fun info() = "Info"
    }
}
fun main() {
    println(Sample.companion.info())
}

medium

A. Incorrect companion object name usage; should be 'Companion' not 'companion'

B. Missing 'object' keyword in companion declaration

C. Function 'info' must be static

D. No error; code runs fine

Solution

1. Step 1: Check companion object name and usage

   The companion object is named 'Companion' with uppercase C.

2. Step 2: Analyze the call in main()

   The code calls 'Sample.companion.info()' with lowercase 'companion', which does not match the name and causes a compile error.

3. Final Answer:

   Incorrect companion object name usage; should be 'Companion' not 'companion' -> Option A

4. Quick Check:

   Use exact companion object name when calling [OK]

Hint: Match companion object name exactly (case sensitive) [OK]

Common Mistakes:

• Using lowercase 'companion' instead of named object
• Forgetting 'object' keyword
• Assuming companion functions must be static

5. You want to create a Kotlin class Logger with a named companion object Factory that provides a method create() returning a new Logger instance. Which code correctly implements this?

hard

A. class Logger {
companion Factory object {
fun create() = Logger()
}
}

B. class Logger {
companion object {
fun create() = Logger()
}
}

C. class Logger {
object Factory companion {
fun create() = Logger()
}
}

D. class Logger {
companion object Factory {
fun create() = Logger()
}
}

Solution

1. Step 1: Recall correct syntax for named companion object

   The correct syntax is 'companion object Factory { ... }' inside the class.

2. Step 2: Check method implementation

   The method 'create()' returns a new instance of Logger using 'Logger()'. class Logger { companion object Factory { fun create() = Logger() } } matches both syntax and logic.

3. Final Answer:

   class Logger { companion object Factory { fun create() = Logger() } } -> Option D

4. Quick Check:

   Named companion object with factory method = class Logger { companion object Factory { fun create() = Logger() } } [OK]

Hint: Use 'companion object Name' and return new instance inside [OK]

Common Mistakes:

• Swapping 'object' and 'companion' keywords
• Omitting the companion object name
• Incorrect order of keywords