Kotlin Object Keyword

In this post we are gonna find out what is the Object keyword in Kotlin and discuss it’s use-cases. in one definition the Object is another way to declare classes but with some differences, the most important difference is that defining an object makes it act like a singleton object, also by defining an object you could use it’s methods and fields as static. in fact the Object is a keyword for multiple approaches to solve our daily challenges in Kotlin, so let’s dive into the usages of this keyword.

Singleton, just one line: In kotlin you could define a singleton class with just declaring it as Object, as easy as it sounds!

object Singleton {

    fun doWhatEver(){
        // logic here...
    }

}

Let’s compare the code above with java Singleton:

public class ThreadSafeSingleton {

    private static ThreadSafeSingleton instance;
    
    private ThreadSafeSingleton(){}
    
    public static synchronized ThreadSafeSingleton getInstance(){
        if(instance == null){
            instance = new ThreadSafeSingleton();
        }
        return instance;
    }
    
}

No need to discuss further!

Static objects: To create objects that act like java static methods, you could use Object keyword, or define a companion object in your desired class.

object StaticClass {

    fun callMeLikeAStaticMethod(){

        // logic here...

    }

}

Then, we use it’s methods as static one’s:

class StaticClassUsage {


    fun someOperationsHere(){

        // use it as static
        StaticClass.callMeLikeAStaticMethod()

    }

}

Or, maybe you want some static methods on your ordinary classes, so:

class Foo {
    
    companion object {

        fun someStaticMethod(){

            // logic here
        }

    }

    fun someUsualMethod(){

        // logic here
    }
    
}

And it’s usage:

class StaticClassUsage {

    private val fooInstance = Foo()


    fun SomeCompanionObjectUseCase(){

        // static using companion obejct
        Foo.someStaticMethod()


        // object field
        fooInstance.someUsualMethod()


    }

}

Kotlin anonymous class implementation: Another usage of kotlin is to define anonymous classes on-fly.

interface SomeInterface {
    
    fun processString() : String
    fun processNothing()
 
}

We could implement the above interface using Object on-fly like:

fun doSomeOperaion(someInterface: SomeInterface) {
      
      someInterface.processNothing()
      someInterface.processString()
      
  }

class AnonymousObjectUsage {

    private val foo = Foo()

    fun someOperationHere(){
        foo.doSomeOperaion(object : SomeInterface{
            override fun processString(): String {
                // logic here
            }

            override fun processNothing() {
                // logic here
            }

        })
    }

}

That’s it, hope you enjoy. feel free to share!.