When to use

• When you want to create an object with small changes of the class without having to explicitly declare the subclass of that class.

Object expression

• Creates an object of an anonymous class that inherits from one or more other types. Such an object is called an anonymous object (the side name is anonymous object), the syntax:
  
  window.addMouseListener(object : MouseAdapter() { override fun mouseClicked(e: MouseEvent) { /*...*/ } override fun mouseEntered(e: MouseEvent) { /*...*/ } })

  1 2 3 4 5

  window.addMouseListener(object : MouseAdapter() {     override fun mouseClicked(e: MouseEvent) { /*...*/ }     override fun mouseEntered(e: MouseEvent) { /*...*/ } })

  
  If the parent type has a constructor, the appropriate parameters must be passed to that constructor. If there are multiple types father inherited / deployment, they are separated by a semicolon separated , :
  
  open class A(x: Int) { public open val y: Int = x } interface B { /*...*/ } val ab: A = object : A(1), B { override val y = 15 }

  1 2 3 4 5 6 7 8 9 10

  open class A(x: Int) {       public open val y: Int = x   }     interface B { /*...*/ }     val ab: A = object : A(1), B {       override val y = 15   }

  
  If only objects are needed, not parent type:
  
  fun foo() { val adHoc = object { var x: Int = 0 var y: Int = 0 } print(adHoc.x + adHoc.y) }

  1 2 3 4 5 6 7 8

  fun foo() {    val adHoc = object {        var x: Int = 0        var y: Int = 0    }    print(adHoc.x + adHoc.y) }

• Anonymous object can be used as a type only if local and private declarations.
• If an anonymous object is used as the return type of the public or the declared type of public properties, the actual type of that method / property will be specified as the type of the parent of the anonymous object or is Any if no parent type has been declared before. And the component added in the anonymous object will be inaccessible:
  
  class C { // Private function, so the return type is the anonymous object type private fun foo() = object { val x: String = "x" } // Public function, so the return type is Any fun publicFoo() = object { val x: String = "x" } fun bar() { val x1 = foo().x // Works val x2 = publicFoo().x // ERROR: Unresolved reference 'x', because anonymous object is used as return type of publicFoo() } }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  class C {     // Private function, so the return type is the anonymous object type     private fun foo() = object {         val x: String = "x"     }       // Public function, so the return type is Any     fun publicFoo() = object {         val x: String = "x"     }       fun bar() {         val x1 = foo().x        // Works         val x2 = publicFoo().x  // ERROR: Unresolved reference 'x', because anonymous object is used as return type of publicFoo()     } }

• The code in an object expression can access variables from a range that surrounds the object expression :
  
  fun countClicks(window: JComponent) { var clickCount = 0 var enterCount = 0 window.addMouseListener(object : MouseAdapter() { override fun mouseClicked(e: MouseEvent) { clickCount++ } override fun mouseEntered(e: MouseEvent) { enterCount++ } }) // ... }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  fun countClicks(window: JComponent) {     var clickCount = 0     var enterCount = 0       window.addMouseListener(object : MouseAdapter() {         override fun mouseClicked(e: MouseEvent) {             clickCount++         }           override fun mouseEntered(e: MouseEvent) {             enterCount++         }     })     // ... }

Object declaration

• Singleton partern can be useful in many cases, declaring singleton in Kotlin is very easy like this:
  
  object DataProviderManager { fun registerDataProvider(provider: DataProvider) { // ... } val allDataProviders: Collection<DataProvider> get() = // ... }

  1 2 3 4 5 6 7 8 9

  object DataProviderManager {     fun registerDataProvider(provider: DataProvider) {         // ...     }       val allDataProviders: Collection<DataProvider>         get() = // ... }

  
  The declaration DataProviderManager as above is the declaration object , and it always has a defined name after the object keyword.
• Like declaring a variable, a object declaration is not an expression, and cannot be used on the right side of an assignment.
• To refer to the object, use its name directly: DataProviderManager.registerDataProvider(...)
• These objects can have parent type
  
  object DefaultListener : MouseAdapter() { override fun mouseClicked(e: MouseEvent) { ... } override fun mouseEntered(e: MouseEvent) { ... } }

  1 2 3 4 5 6

  object DefaultListener : MouseAdapter() {     override fun mouseClicked(e: MouseEvent) { ... }       override fun mouseEntered(e: MouseEvent) { ... } }

• Object daclaration cannot be local (eg in a method), but it can be declared in another daclaration object or a non-inner class.

Companion object

• The declaration object inside a class can be marked with the companion keyword:
  
  class MyClass { companion object Factory { fun create(): MyClass = MyClass() } }

  1 2 3 4 5 6

  class MyClass {     companion object Factory {         fun create(): MyClass = MyClass()     } }

• Companion object components can be called by separating the class name: val instance = MyClass.create()
• There is a tag that does not need to declare the name of companion object , in this case the name Companion will be used:
  
  class MyClass { companion object { } } val x = MyClass.Companion

  1 2 3 4 5 6

  class MyClass {     companion object { } }   val x = MyClass.Companion

• Although companion object components seem like static components in other languages, at runtime they are still and instances of an actual object and can do a number of things, such as implementing interfaces:
  
  interface Factory<T> { fun create(): T } class MyClass { companion object : Factory<MyClass> { override fun create(): MyClass = MyClass() } } val f: Factory<MyClass> = MyClass

  1 2 3 4 5 6 7 8 9 10 11 12

  interface Factory<T> {     fun create(): T }   class MyClass {     companion object : Factory<MyClass> {         override fun create(): MyClass = MyClass()     } }   val f: Factory<MyClass> = MyClass

• However, companion object components can be created as static methods and static fields if using JvmStatic annotation.

Difference

• Some important differences between object expression and declaration object :

1. Object expression is executed and instantiated as soon as it is used.
2. The Object declaration is initialized late when the object is first accessed.
3. Companion object is instantiated when the corresponding class is uploaded,