Companion objects as static alternatives in Kotlin

Introduction

Companion objects let you create functions and properties that belong to a class itself, not to its instances. They work like static members in other languages.

When you want to group helper functions related to a class but not tied to any object.

When you need to create factory methods to build instances in a special way.

When you want to hold constants inside a class for easy access.

When you want to access class-level properties or methods without creating an object.

Syntax

Kotlin

class MyClass {
    companion object {
        // static-like members here
        val constant = 42
        fun greet() = "Hello from companion"
    }
}

The companion object is a singleton object inside the class.

You access its members using the class name, like MyClass.greet().

Examples

Defines a companion object with a static-like add function. Called using the class name.

Kotlin

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

fun main() {
    println(Calculator.add(3, 4))
}

Stores a constant inside the companion object, accessed via the class.

Kotlin

class Person {
    companion object {
        const val species = "Homo sapiens"
    }
}

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

Uses companion object to create a static-like log function.

Kotlin

class Logger {
    companion object {
        fun log(message: String) {
            println("LOG: $message")
        }
    }
}

fun main() {
    Logger.log("App started")
}

Sample Program

This program converts Celsius to Fahrenheit using a companion object function. We call the function without creating an object.

Kotlin

class TemperatureConverter {
    companion object {
        fun celsiusToFahrenheit(celsius: Double): Double {
            return celsius * 9 / 5 + 32
        }
    }
}

fun main() {
    val tempC = 25.0
    val tempF = TemperatureConverter.celsiusToFahrenheit(tempC)
    println("$tempC°C is $tempF°F")
}

Important Notes

Companion objects are initialized when the class is loaded, so their members are ready to use anytime.

You can name companion objects, but if you don't, the default name is Companion.

Companion object members can implement interfaces, which is useful for some design patterns.

Summary

Companion objects provide a way to create static-like members inside Kotlin classes.

They are useful for constants, factory methods, and utility functions related to the class.

You access companion object members using the class name without creating an instance.

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