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.