Объектные выражения и объявления

Создание анонимных объектов с нуля

Объектные выражения начинаются со слова object.

Если вам просто нужен объект, у которого нет нетривиальных супертипов, запишите его члены в фигурные скобки после object:

fun main() {
//sampleStart
    val helloWorld = object {
        val hello = "Hello"
        val world = "World"
        // object expressions extend Any, so `override` is required on `toString()`
        override fun toString() = "$hello $world"
    }
//sampleEnd
    print(helloWorld)
}

Наследование анонимных объектов от супертипов

Чтобы создать объект анонимного класса, который наследуется от некоторого типа (или типов), укажите этот тип после object и двоеточия (:). Затем реализуйте или переопределите члены этого класса так, как будто вы наследуете от него:

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

    override fun mouseEntered(e: MouseEvent) { /*...*/ }
})

Если супертип имеет конструктор, передайте соответствующие параметры конструктора в него. Несколько супертипов можно указать как список, разделенный запятыми, после двоеточия:

open class A(x: Int) {
    public open val y: Int = x
}

interface B { /*...*/ }

val ab: A = object : A(1), B {
    override val y = 15
}

Использование анонимных объектов в качестве типов возврата и значений

Когда анонимный объект используется в качестве типа локальной или приватной, но не встроенной декларации (функции или свойства), все его члены доступны через эту функцию или свойство:

class C {
    private fun getObject() = object {
        val x: String = "x"
    }

    fun printX() {
        println(getObject().x)
    }
}

Если эта функция или свойство являются общедоступными или встроенными, их фактический тип:

• Any если анонимный объект не имеет объявленного супертипа

• Объявленный супертип анонимного объекта, если существует ровно один такой тип

• Явно объявленный тип, если объявлено более одного супертипа

Во всех этих случаях члены, добавленные в анонимный объект, недоступны. Переопределенные члены доступны, если они объявлены в фактическом типе функции или свойства:

interface A {
    fun funFromA() {}
}
interface B

class C {
    // The return type is Any. x is not accessible
    fun getObject() = object {
        val x: String = "x"
    }

    // The return type is A; x is not accessible
    fun getObjectA() = object: A {
        override fun funFromA() {}
        val x: String = "x"
    }

    // The return type is B; funFromA() and x are not accessible
    fun getObjectB(): B = object: A, B { // explicit return type is required
        override fun funFromA() {}
        val x: String = "x"
    }
}

Доступ к переменным из анонимных объектов

Код в объектных выражениях может обращаться к переменным из окружающего пространства имен:

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 объявления на Kotlin вы увидите, что его строковое представление содержит как его имя, так и хэш объекта:

object MyObject

fun main() {
    println(MyObject) // MyObject@1f32e575
}

Так же, как и классы данных, вы можете пометить объявление object модификатором data, чтобы получить красиво отформатированное строковое представление без необходимости вручную предоставлять реализацию для функции toString:

data object MyObject

fun main() {
    println(MyObject) // MyObject
}

Иерархии закрытых классов особенно хорошо подходят для объявления data object , так как позволяют сохранять симметрию с любыми классами данных, которые вы могли определить рядом с объектом:

sealed class ReadResult {
    data class Number(val value: Int): ReadResult()
    data class Text(val value: String): ReadResult()
    data object EndOfFile: ReadResult()
}

fun main() {
    println(ReadResult.Number(1)) // Number(value=1)
    println(ReadResult.Text("Foo")) // Text(value=Foo)
    println(ReadResult.EndOfFile) // EndOfFile
}

Объекты-компаньоны

Объявление объекта внутри класса может быть помечено ключевым словом companion:

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

Члены объекта-компаньона могут вызываться, просто используя имя класса в качестве квалификатора:

val instance = MyClass.create()

Имя объекта-компаньона можно опустить, в этом случае будет использовано имя Companion:

class MyClass {
    companion object { }
}

val x = MyClass.Companion

Члены класса могут обращаться к закрытым членам соответствующего объекта-компаньона.

Имя класса, используемое само по себе (не в качестве квалификатора к другому имени), действует как ссылка на объект-компаньон класса (именованного или нет):

class MyClass1 {
    companion object Named { }
}

val x = MyClass1

class MyClass2 {
    companion object { }
}

val y = MyClass2

Обратите внимание, что, хотя члены объектов-компаньонов выглядят как статические члены в других языках, во время выполнения это все еще члены экземпляров реальных объектов и могут, например, реализовывать интерфейсы:

interface Factory<T> {
    fun create(): T
}

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

val f: Factory<MyClass> = MyClass

Однако на JVM члены объектов-компаньонов могут быть сгенерированы как реальные статические методы и поля, если вы используете аннотацию @JvmStatic. Подробнее см. раздел взаимодействия с Java.

Семантическое различие между объектами выражениями и объявлениями

Существует важное семантическое различие между объектами-выражениями и объявлениями объектов:

• Объектные выражения выполняются (и инициализируются) немедленно, где они используются.

• Объектные объявления инициализируются лениво, при первом обращении.

• Объект-компаньон инициализируется при загрузке (разрешении) соответствующего класса, что соответствует семантике статического инициализатора Java.