The Power of the object Keyword in Kotlin: A Guide to Singleton, Companion Objects, and Object Expressions

March 2025
M	T	W	T	F	S	S
	1	2
3	4	5	6	7	8	9
10	11	12	13	14	15	16
17	18	19	20	21	22	23
24	25	26	27	28	29	30
31

The Power of the object Keyword in Kotlin: A Guide to Singleton, Companion Objects, and Object Expressions

Kotlin offers a unique feature for developers to streamline their code: the object keyword. This keyword is an essential part of the Kotlin language that serves several purposes, from creating singletons to managing companion objects and even enabling object expressions. In this blog, we will break down how the object keyword is used in Kotlin and explore its capabilities in various scenarios.

1. Creating Singletons in Kotlin

In many programming languages, singletons are often created using static methods or variables. In Kotlin, the object keyword simplifies this process significantly by automatically creating a singleton instance of a class.

Example of a Singleton:

object Transmogrifier {
    fun transmogrify() {
        println("Presto, change-o!")
    }
}

fun main() {
    Transmogrifier.transmogrify()
}

object Transmogrifier {

fun transmogrify() {

println("Presto, change-o!")

}

fun main() {

Transmogrifier.transmogrify()

}

With this approach, there’s no need to explicitly create an instance of the Transmogrifier class. The object keyword ensures that the class is instantiated only once, and you can access its methods directly.

2. True Singleton vs. Quasi-Singleton

Though you can create a quasi-singleton using a val declaration, it doesn’t truly restrict the creation of multiple instances. For example:

val QUASI_SINGLETON = Transmogrifier()

1 2	val QUASI_SINGLETON = Transmogrifier()

This does not prevent the creation of additional instances of the Transmogrifier class. In contrast, the object keyword ensures a single instance is created and used throughout your application. This can prevent issues like memory leaks and accidental multiple instances of your class.

3. Companion Objects in Kotlin

In Kotlin, a companion object is a singleton that is tied to a class. It serves a similar role to static methods in Java, allowing you to call methods without needing an instance of the class. Companion objects are defined inside a class using the companion object keyword.

Example of a Companion Object:

class Thingy {
    companion object {
        fun doSomething() {
            println("Ummm... is this something?")
        }
    }
}

fun main() {
    Thingy.doSomething()
}

class Thingy {

companion object {

fun doSomething() {

println("Ummm... is this something?")

}

fun main() {

Thingy.doSomething()

}

The companion object allows you to access methods just like static methods in Java. However, it also has access to the private members of the class, which is a significant advantage when you need to operate on class-specific data without an instance.

4. Using Named Companion Objects

A companion object can also be given a name, which helps with organizing your code. This named companion object can still be accessed via the class, as shown in the example below:

class Thingy {
    private val count = 1

    companion object AmyPond {
        fun doSomething(thingy: Thingy) {
            println(thingy.count)
        }
    }
}

fun main() {
    Thingy.doSomething(Thingy())
}

class Thingy {

private val count = 1

companion object AmyPond {

fun doSomething(thingy: Thingy) {

println(thingy.count)

}

fun main() {

Thingy.doSomething(Thingy())

}

While naming a companion object has little impact on your Kotlin code’s structure, it can be helpful if you’re dealing with Java interoperability or more complex applications.

5. Object Expressions: Anonymous Classes in Kotlin

When working with UI elements or event handlers, you may need to create anonymous classes in Java. Kotlin offers a cleaner way to handle this through object expressions. This allows you to create an instance of a class or interface without needing a separate class declaration.

Example of Object Expression:

fun clickyClickyClicky(view: View) {
    view.setOnClickListener(object : OnClickListener {
        override fun onClick(v: View) {
            println("Button clicked!")
        }
    })
}

fun clickyClickyClicky(view: View) {

view.setOnClickListener(object : OnClickListener {

override fun onClick(v: View) {

println("Button clicked!")

}

})

}

In this example, an OnClickListener is created using an object expression, implementing the OnClickListener interface directly within the method. It’s concise, easy to understand, and removes the need for an explicit class declaration.

6. Constructors and Parameters in Object Expressions

Object expressions can extend other classes or implement interfaces. If the class or interface has a constructor, you can pass parameters within the object expression:

abstract class OnClickListener(val label: String) {
    abstract fun onClick(v: View)
}

class View {
    fun setOnClickListener(listener: OnClickListener) {
        // Handle the listener
    }
}

fun clickyClickyClicky(view: View) {
    view.setOnClickListener(object : OnClickListener("Button") {
        override fun onClick(v: View) {
            println("$label clicked!")
        }
    })
}

abstract class OnClickListener(val label: String) {

abstract fun onClick(v: View)

}

class View {

fun setOnClickListener(listener: OnClickListener) {

// Handle the listener

}

fun clickyClickyClicky(view: View) {

view.setOnClickListener(object : OnClickListener("Button") {

override fun onClick(v: View) {

println("$label clicked!")

}

})

}

In this case, the object expression extends the OnClickListener class and passes a parameter to the constructor, demonstrating how flexible object expressions can be.

7. Access to Local Variables in Object Expressions

A powerful feature of Kotlin’s object expressions is that they can access local variables from the enclosing scope. This is much more flexible than in Java, where you must use final variables. Kotlin allows you to directly modify these variables within the object expression.

Example:

fun clickyClickyClicky(view: View) {
    var clicks = 0
    view.setOnClickListener(object : OnClickListener {
        override fun onClick(v: View) {
            clicks++
            println(clicks)
        }
    })
}

fun clickyClickyClicky(view: View) {

var clicks = 0

view.setOnClickListener(object : OnClickListener {

override fun onClick(v: View) {

clicks++

println(clicks)

}

})

}

In this scenario, the clicks variable is incremented every time the onClick method is called, which would be impossible in Java without additional code or annotations.

8. The SAM (Single Abstract Method) Pattern

Kotlin also allows you to use lambda expressions to simplify object expressions in cases where the interface only has a single abstract method (SAM). This is an excellent feature for reducing boilerplate code, especially in event-driven programming.

Example:

val listener = OnClickListener { v: View -&gt; println("Clicked!") }

1 2	val listener = OnClickListener { v: View -> println("Clicked!") }

This lambda expression is an example of the SAM pattern, where Kotlin can implicitly handle the interface implementation.

Conclusion

The object keyword in Kotlin provides a variety of tools to make your code more concise, flexible, and powerful. Whether you’re creating singletons, defining companion objects, or using object expressions to simplify your code, Kotlin’s use of the object keyword helps reduce complexity and improve readability.

By mastering these features, you can write more efficient, elegant Kotlin code that takes full advantage of the language’s object-oriented capabilities.