Named companion objects in Kotlin - Step-by-Step Execution

Concept Flow - Named companion objects

Class Declaration

↓

Define Named Companion Object

↓

Access Companion Object Members

↓

Use Named Companion Object Name

↓

Program Output or Behavior

The flow shows defining a class with a named companion object and accessing its members using the companion's name.

Execution Sample

Kotlin

class MyClass {
    companion object Factory {
        fun create() = MyClass()
    }
}

val instance = MyClass.Factory.create()

Defines a class with a named companion object 'Factory' and calls its create() function.

Execution Table

Step	Action	Evaluation	Result
1	Class MyClass loaded	Companion object Factory created	Factory object ready with create()
2	Call MyClass.Factory.create()	Invoke create() function	New MyClass instance created
3	Assign instance	instance = MyClass.Factory.create()	instance holds MyClass object
4	Program ends	No more actions	instance available for use

💡 Program ends after creating instance using named companion object Factory.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
instance	null	MyClass instance	MyClass instance	MyClass instance

Key Moments - 2 Insights

Why do we use a named companion object instead of the default unnamed one?

Naming the companion object (like 'Factory') allows us to refer to it explicitly, which can improve code clarity and avoid confusion, as shown in step 2 where we call MyClass.Factory.create().

Can we access companion object members without the companion's name?

Yes, if the companion object is unnamed, members can be accessed directly via the class name. But with a named companion, you must use the companion's name as in step 2.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'instance' after step 3?

A null

B MyClass instance

C Factory object

D create() function

💡 Hint

Check the variable_tracker row for 'instance' after step 3.

At which step is the companion object 'Factory' created?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

See execution_table row 1 describing class loading and companion creation.

If the companion object was unnamed, how would the call in step 2 change?

A Factory.create()

B MyClass.Factory.create()

C MyClass.create()

D create()

💡 Hint

Named companion requires the name; unnamed allows direct class access (see key_moments).

Concept Snapshot

Named companion objects in Kotlin:
- Syntax: companion object Name { ... }
- Access members via Class.Name.member
- Useful for clarity and avoiding conflicts
- Members behave like static members
- Allows factory methods or constants inside class

Full Transcript

This visual trace shows how Kotlin named companion objects work. First, the class is loaded and its named companion object 'Factory' is created. Then, we call the create() function via MyClass.Factory.create(), which returns a new MyClass instance. This instance is assigned to the variable 'instance'. The companion object must be accessed by its name when named, unlike unnamed companions where members can be accessed directly via the class name. This helps organize code and clarify usage. The variable tracker shows 'instance' changes from null to holding the new object after creation. The quiz questions reinforce understanding of companion object creation, member access, and naming effects.

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