Kotlin: Difference between object and companion ob

Question

What is the difference between an object and a companion object in a class in kotlin?

Example:

class MyClass {

    object Holder {
        //something
    }

    companion object {
        //something
    }
}

I already read that companion object shall be used, if the containing parameters/methods are closely related to its class.

But why is there also the possibility of declaring a normal object in the class? Because it behaves exactly like the companion, but it must have a name.

Is there maybe a difference in its "static" (I'm from the java side) lifecycle?

Answer 1

Objects can implement interfaces. Inside a class, defining a simple object that doesn't implement any interfaces has no benefit in most cases. However, defining multiple objects that implement various interfaces (e.g. Comparator) can be very useful.

In terms of lifecycle, there is no difference between a companion object and a named object declared in a class.

Answer 2

An object, or an object declaration, is initialized lazily, when accessed for the first time.

A companion object is initialized when the corresponding class is loaded. It brings about the 'static' essence, although Kotlin does not inherently support static members.

Answer 3

There are two different types of object uses, expression and declaration.

Object Expression

An object expression can be used when a class needs slight modification, but it's not necessary to create an entirely new subclass for it. Anonymous inner classes are a good example of this.

    button.setOnClickListener(object: View.OnClickListener() {
        override fun onClick(view: View) {
            // click event
        }
    })

One thing to watch out for is that anonymous inner classes can access variables from the enclosing scope, and these variables do not have to be final. This means that a variable used inside an anonymous inner class that is not considered final can change value unexpectedly before it is accessed.

Object Declaration

An object declaration is similar to a variable declaration and therefore cannot be used on the right side of an assignment statement. Object declarations are very useful for implementing the Singleton pattern.

    object MySingletonObject {
        fun getInstance(): MySingletonObject {
            // return single instance of object
        }
    }

And the getInstance method can then be invoked like this.

    MySingletonObject.getInstance()

Companion Object

A companion object is a specific type of object declaration that allows an object to act similar to static objects in other languages (such as Java). Adding companion to the object declaration allows for adding the "static" functionality to an object even though the actual static concept does not exist in Kotlin. Here's an example of a class with instance methods and companion methods.

 class MyClass {
        companion object MyCompanionObject {
            fun actsAsStatic() {
                // do stuff
            }
        }

       fun instanceMethod() {
            // do stuff
        }
    }

Invoking the instance method would look like this.

    var myClass = MyClass()
    myClass.instanceMethod()

Invoking the companion object method would look like this.

    MyClass.actsAsStatic()

See the Kotlin docs for more info.

Answer 4

Companion object exists because you can call companion objects' functions/properties like it is a java static method/field. And for why your Holder is allowed, well, there is no reason that declaring a nested object is illegal. It may comes in handy sometimes.