Static vs. Companion Objects in Kotlin: A Guide on Functionality and Usage

Static vs. Companion Objects in Kotlin

Kotlin, a modern programming language, offers various features that enhance code readability, maintainability, and efficiency. Two important concepts within Kotlin are Static Objects and Companion Objects. These concepts might seem similar at first glance, but they serve distinct purposes in the world of programming. In this comprehensive guide, we will dive deep into the differences between Static and Companion Objects in Kotlin, providing you with a clear understanding of their roles and applications.

Imagine you’re part of a team building a recipe book application. Each recipe is represented by a class. Now, you want to add some shared information or functionality that belongs to the recipe class as a whole, not just to individual recipes.

Static Members in Java

Think of static members in Java like a recipe book that has a special page where all chefs can write down their favorite ingredients. This special page is shared among all the recipe books, and whenever a chef adds an ingredient to it, it appears in all the recipe books. 

In this analogy, the special page is like a static variable, and the act of adding ingredients is like calling a static method. 

All the recipe books have access to the same special page, and all chefs can use it without needing to create their own recipe book.

Companion Objects in Kotlin

Now, consider companion objects in Kotlin as a group of chefs who collaborate to create new recipes. They have their own special kitchen where they share unique spices and tools.

 This special kitchen is like a companion object. Each group of chefs has its own kitchen with its own set of special spices and tools. Just like static members, these special kitchens are accessible without creating individual chef groups. Chefs can use the unique spices and tools from their kitchen when they’re cooking up new recipes together.

• Static Members (Java): Shared information or actions available to all instances of a class. Think of a shared page in all recipe books.
• Companion Objects (Kotlin): Special groups within a class with their own unique resources. Imagine groups of chefs with their own shared kitchen.

In this way, both static members and companion objects provide ways to add shared features or tools at the class level, but companion objects offer more customization and flexibility for different groups of functionalities within the class.

Static vs. Companion Objects in Kotlin

In Kotlin, there’s no direct “static“

In Kotlin, there’s no direct “static” keyword like in some other programming languages. Instead, you define top-level properties and functions outside of any class, which serves a similar purpose to static members.

Static Example: Let’s say we’re creating a simple utility to convert temperatures between Celsius and Fahrenheit. In this case, we’ll use a top-level function to achieve this.

// Top-level function to convert Celsius to Fahrenheit
fun celsiusToFahrenheit(celsius: Double): Double {
    return celsius * 9 / 5 + 32
}

// Using the top-level function
val celsiusValue = 25.0
val fahrenheitValue = celsiusToFahrenheit(celsiusValue)
println("$celsiusValue Celsius is $fahrenheitValue Fahrenheit")

Companion Objects example

Companion objects are used within classes to create members that are associated with the class itself. They’re similar to static members, but they offer more flexibility and can be used to implement interfaces or be extended.

Companion Example: Let’s create a simple class representing a book, and within it, we’ll use a companion object to keep track of the total number of books created.

class Book(val title: String) {
    companion object {
        private var totalBooks = 0
        
        fun getTotalBooks(): Int {
            return totalBooks
        }
        
        fun createBookWithTitle(title: String): Book {
            totalBooks++
            return Book(title)
        }
    }
}

// Using the companion object
val book1 = Book.createBookWithTitle("The Great Gatsby")
val book2 = Book.createBookWithTitle("To Kill a Mockingbird")

println("Total books created: ${Book.getTotalBooks()}")

In this example, the companion object is like a special section inside the Book class that has its own members. It keeps track of how many books have been created overall.

Remember, companion objects allow you to group related functionality within a class and provide better encapsulation compared to traditional static member

Companion Objects, on the other hand, are more versatile. They are defined within a class and are used to hold properties and methods that are related to the class itself. Each class can have only one Companion Object, and it’s named Companion by default. Companion Objects can be instantiated lazily.

Use Cases of Companion Objects:

1. Factory Methods: Companion Objects are often utilized to create instances of their enclosing class. This provides a more expressive and readable way to instantiate objects compared to traditional constructors.
2. Private Members: When a method or property needs to be accessible only within the class, it can be defined in the Companion Object to encapsulate its scope.
3. Interface Implementation: Companion Objects can implement interfaces, enabling the class to provide a unified implementation of the interface’s methods.

Factory Methods: Imagine you’re creating a class to represent different types of vehicles. Instead of using a regular constructor to create instances of these vehicles, you can use a companion object to provide a clearer and more organized way of creating them. For instance:

class Vehicle(val type: String) {
    companion object {
        fun createCar(): Vehicle {
            return Vehicle("Car")
        }
        fun createMotorcycle(): Vehicle {
            return Vehicle("Motorcycle")
        }
    }
}

Now you can create instances like this:

val car = Vehicle.createCar()

This makes the code more readable and helps avoid confusion about which constructor to call.

Private Members: Sometimes, you might have methods or properties in a class that should only be used within the class itself and not by external code. Placing them in a companion object keeps them private and encapsulated within the class:

class SecretManager {
    companion object {
        private fun accessSecretData(): String {
            return "Super secret data"
        }
    }
}

Now, the accessSecretData method can only be accessed within the SecretManager class.

Interface Implementation: If a class needs to implement an interface, and the implementation should be consistent for all instances, you can use a companion object to provide the implementation. This is especially useful when the interface methods have default implementations:

interface Speaker {
    fun speak(message: String)
}

class Human : Speaker {
    companion object : Speaker {
        override fun speak(message: String) {
            println("Human says: $message")
        }
    }
}

Here, the Human class uses a companion object to implement the Speaker interface in a uniform way for all humans.

These are just a few examples of how companion objects are used in programming. They help improve code organization, maintainability, and encapsulation by grouping related functionality together and making it more accessible or restricted as needed.

Exploring the Differences Static vs. Companion Objects in Kotlin

Here’s a summarized comparison between Static Objects and Companion Objects:

Static Members in Java:

public class RecipeJava {
    public static String sharedIngredient = "Salt";

    public static void addSharedIngredient(String ingredient) {
        sharedIngredient += ", " + ingredient;
    }
}

public class MainJava {
    public static void main(String[] args) {
        System.out.println("Shared ingredient: " + RecipeJava.sharedIngredient);
        
        RecipeJava.addSharedIngredient("Pepper");
        
        System.out.println("Updated shared ingredient: " + RecipeJava.sharedIngredient);
    }
}

In this example, the RecipeJava class has a static variable sharedIngredient that is shared among all instances of the class. The addSharedIngredient static method adds ingredients to this shared variable. The MainJava class demonstrates how the shared ingredient is accessed and updated using static members.

Companion Objects in Kotlin:

class RecipeKotlin {
    companion object {
        var uniqueSpice = "Cinnamon"

        fun addUniqueSpice(spice: String) {
            uniqueSpice += ", $spice"
        }
    }
}

fun main() {
    println("Unique spice: " + RecipeKotlin.Companion.uniqueSpice)
    
    RecipeKotlin.addUniqueSpice("Vanilla")
    
    println("Updated unique spice: " + RecipeKotlin.Companion.uniqueSpice)
}

In this example, the RecipeKotlin class has a companion object that acts like a group of chefs with their own shared resources. The uniqueSpice property and addUniqueSpice method are part of this companion object. The main function demonstrates how the unique spice is accessed and updated using companion object members.

Remember, the key difference is that in the Java example, you access static members using the class name (RecipeJava.sharedIngredient), while in the Kotlin example, you access companion object members using the class name followed by Companion (RecipeKotlin.Companion.uniqueSpice).

Companion Objects in Kotlin Example

In Kotlin, companion objects are used to define properties and methods that belong to the class itself rather than to instances of the class.(These properties and methods are like tools and information that are directly associated with the idea of the class, not with any individual objects created from that class.)

They are commonly used in Android app development to create utility functions, constants, or factory methods related to a class. Here’s an example of how companion objects can be used in an Android app

class NetworkUtils {

    // Regular member function
    fun performNetworkRequest(url: String) {
        // Code to perform a network request
    }

    companion object {
        const val BASE_URL = "https://api.example.com"
        
        // Factory method to create an instance with a custom timeout
        fun createWithTimeout(timeout: Int): NetworkUtils {
            val networkUtils = NetworkUtils()
            // Configure the timeout
            // ...
            return networkUtils
        }
    }
}

In this example, we have a NetworkUtils class that encapsulates networking-related functionality. Inside the class, we have a regular member function performNetworkRequest that is called on instances of the class.

The interesting part is the companion object block.

Inside the companion object, we define properties and methods that are associated with the class itself, not with instances.

In this case, we’ve defined a constant BASE_URL that can be accessed using NetworkUtils.BASE_URL without creating an instance of the class.

We’ve also defined a factory method createWithTimeout that creates an instance of NetworkUtils with a custom timeout configuration.

Android developers often use companion objects to define constants, helper functions, and factory methods that are related to a particular class and can be accessed without creating instances. This helps organize code and make it more readable and maintainable.

For beginner

Imagine you have a magic toolbox that helps you talk to faraway places on the internet. This toolbox has a lot of tools and tricks to make sure your messages reach their destinations and come back to you.

Now, let’s say you’re building a special kind of phone that can use this magic toolbox to send and receive messages from the internet. You’ll need a way to use the tools in the toolbox to send messages and receive responses.

In this case, the NetworkUtils class is like a blueprint for building these special phones. Inside the blueprint, there’s a set of instructions for sending and receiving messages using the magic toolbox.

Here’s what’s happening in the blueprint:

1. Sending Messages: There’s a special set of instructions called a function (imagine it like a recipe) named performNetworkRequest. This function helps the phone send messages over the internet using the magic toolbox.
2. Important Information: Inside the blueprint, there’s a special box called BASE_URL that holds the main address for the internet place you want to talk to. This is like having the address of a friend’s house where you want to send a letter.
3. Custom Phones: There’s a special area in the blueprint called a “companion object.” This area is like a factory that can create custom phones with different settings. For example, if you want a phone that can send messages really quickly, you can tell the factory to make a phone with that feature.

So, in simple terms:

• The blueprint (NetworkUtils class) tells you how to use the magic toolbox to send and receive messages on the internet.
• There’s a specific place in the blueprint where you can find important information, like the main address for the internet place you want to talk to.
• The blueprint also has a factory that can create customized phones with special features.

In the end, this blueprint helps programmers make sure the special phones they build can communicate with the internet effectively, just like your real phone does with your friends!

FAQs

What is the main difference between Static and Companion Objects?

Static Objects are defined outside the class and are accessible through the class name. They cannot be initialized lazily and are created as soon as they are referenced. On the other hand, Companion Objects are declared within the class and can be instantiated lazily. They often serve as factories for creating instances of their enclosing class and can implement interfaces.

Can I define multiple Companion Objects within a single class?

No, you can only define a single Companion Object within a class. It’s named Companion by default. However, you can have multiple Static Objects within a class.

How do Companion Objects support interface implementation?

Companion Objects can implement interfaces just like regular classes. This allows the class to provide a unified implementation of the interface’s methods. This is particularly useful when you want to maintain a single implementation across multiple instances of the class.

Can I access private members of a class through its Companion Object?

Yes, you can. If a method or property is defined within the Companion Object, it has access to private members of the class. This encapsulates the private scope within the Companion Object.

Are Static Objects and Companion Objects inheritable?

No, neither Static Objects nor Companion Objects are inheritable. They are tied to the specific class in which they are defined and cannot be inherited by subclasses.

When should I use Static Objects, and when should I use Companion Objects?

Use Static Objects when you need constants, utility functions, or a global state manager that doesn’t change across instances. Use Companion Objects when you want to provide a more expressive way to instantiate objects, encapsulate private members, or implement interfaces within the context of a class.

Feel free to follow and join my email list at no cost. Don’t miss out — sign up now!

Please check out my earlier blog post for more insights. Happy reading!

The Innovative Fundamentals of Android App Development in 2023

How to learn Android App Development in 2023 – Full Guide For Beginners using Kotlin Language

Ultimate Guideline on How to Use ViewModel Design Pattern

What is the Repository Pattern in Android? A Comprehensive Guide

What is ViewModel in Android? A Good Guide for Beginners

The Innovative Fundamentals of Android App Development in 2023

How to Say Goodbye to Activity Lifecycle and Say Hello to Compose Lifecycle ?

How to Monitor/Observe Network Availability for Android Projects

Exploring Sealed Class vs Enum in Kotlin Which is Best for Your Code?

What is the difference between Functional Programming and OOP?

Memory Leaks in Android Development A Complete Guide