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

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

Объектные выражения начинаются с ключевого слова 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++
        }
    })
    // ...
}

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

Объектное объявление внутри класса может быть помечено ключевым словом 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.