Объектные выражения и объявления объектов в Kotlin
Kotlin использует объектные выражения и объектные объявления для создания объекта класса с небольшими изменениями без необходимости объявлять новый подкласс.
Объектные выражения
Используйте объектное выражение для создания объекта анонимного внутреннего класса, чтобы использовать его в качестве параметра метода:
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
}
Если у супертипа есть конструктор, ему необходимо передать параметры. Несколько супертипов и интерфейсов можно разделять запятыми.
С помощью объектного выражения можно напрямую получить объект, не прибегая к определению класса:
fun main(args: Array<String>) {
val site = object {
var name: String = "Example"
var url: String = "www.example.com"
}
println(site.name)
println(site.url)
}
Обратите внимание, что анонимные объекты можно использовать как типы, объявленные только в локальных и приватных областях видимости. Если вы используете анонимный объект как возвращаемый тип публичной функции или как тип публичного свойства, фактическим типом этой функции или свойства будет супертип, объявленный анонимным объектом, или Any, если супертип не объявлен. Добавленные в анонимном объекте члены будут недоступны.
class C {
// 私有函数,所以其返回类型是匿名对象类型
private fun foo() = object {
val x: String = "x"
}
// 公有函数,所以其返回类型是 Any
fun publicFoo() = object {
val x: String = "x"
}
fun bar() {
val x1 = foo().x // 没问题
val x2 = publicFoo().x // 错误:未能解析的引用“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++
}
})
// ……
}
Объявления объектов
Kotlin использует ключевое слово `object` для объявления объекта.
В Kotlin можно удобно получить синглтон с помощью объявлений объектов.
object DataProviderManager {
fun registerDataProvider(provider: DataProvider) {
// ……
}
val allDataProviders: Collection<DataProvider>
get() = // ……
}
Чтобы сослаться на этот объект, можно просто использовать его имя:
DataProviderManager.registerDataProvider(……)
Конечно, можно также определить переменную, чтобы получить этот объект. Однако если вы определите две разные переменные для получения этого объекта, то обнаружите, что не можете получить две разные переменные. Иными словами, таким способом мы получаем синглтон.
var data1 = DataProviderManager
var data2 = DataProviderManager
data1.name = "test"
print("data1 name = ${data2.name}")
Пример
В следующем примере оба объекта выводят один и тот же URL-адрес:
object Site {
var url:String = ""
val name: String = "Example"
}
fun main(args: Array<String>) {
var s1 = Site
var s2 = Site
s1.url = "www.example.com"
println(s1.url)
println(s2.url)
}
Результат вывода:
www.example.com www.example.com
У объектов могут быть супертипы:
object DefaultListener : MouseAdapter() {
override fun mouseClicked(e: MouseEvent) {
// ……
}
override fun mouseEntered(e: MouseEvent) {
// ……
}
}
В отличие от объектных выражений, когда объект объявлен внутри другого класса, к этому объекту нельзя получить доступ через экземпляр внешнего класса, а только через имя класса. Также объект не может напрямую обращаться к методам и переменным внешнего класса.
class Site {
var name = "Example"
object DeskTop{
var url = "www.example.com"
fun showName(){
print{"desk legs $name"} // 错误,不能访问到外部类的方法和变量
}
}
}
fun main(args: Array<String>) {
var site = Site()
site.DeskTop.url // 错误,不能通过外部类的实例访问到该对象
Site.DeskTop.url // 正确
}
Сопутствующие объекты
Объявление объекта внутри класса можно пометить ключевым словом `companion`, чтобы связать его с внешним классом, и мы можем напрямую обращаться к внутренним элементам объекта через внешний класс.
class MyClass {
companion object Factory {
fun create(): MyClass = MyClass()
}
}
val instance = MyClass.create() // 访问到对象的内部元素
Мы можем опустить имя объекта, а затем использовать `Companion` вместо имени, которое нужно объявить:
class MyClass {
companion object {
}
}
val x = MyClass.Companion
Примечание:В классе можно объявить только один внутренне связанный объект, то есть ключевое слово `companion` можно использовать только один раз.
Члены сопутствующего объекта выглядят как статические члены в других языках, но во время выполнения они всё ещё являются членами экземпляра реального объекта. Например, он также может реализовывать интерфейсы:
interface Factory<T> {
fun create(): T
}
class MyClass {
companion object : Factory<MyClass> {
override fun create(): MyClass = MyClass()
}
}
Семантические различия между объектными выражениями и объявлениями объектов
Существует важное семантическое различие между объектными выражениями и объявлениями объектов:
-
Объектные выражения выполняются сразу в месте их использования.
Объявления объектов лениво инициализируются при первом обращении.
Инициализация сопутствующего объекта происходит при загрузке (разрешении) соответствующего класса, что соответствует семантике статических инициализаторов Java.