Kotlin Expresiones de objeto y declaraciones de objeto

Kotlin usa expresiones de objeto y declaraciones de objeto para crear un objeto de una clase con ligeras modificaciones sobre una clase determinada, sin necesidad de declarar una nueva subclase.


Expresión de objeto

Se utiliza una expresión de objeto para implementar un objeto de una clase interna anónima como parámetro de un método:

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

El objeto puede heredar de una clase base o implementar otras interfaces:

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

interface B {……}

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

Si el supertipo tiene un constructor, se le deben pasar parámetros. Varios supertipos e interfaces se pueden separar con comas.

Con las expresiones de objeto se puede obtener un objeto directamente sin definir una clase:

fun main(args: Array<String>) {
    val site = object {
        var name: String = "Ejemplo"
        var url: String = "www.example.com"
    }
    println(site.name)
    println(site.url)
}

Ten en cuenta que los objetos anónimos solo se pueden usar como tipos declarados en alcance local o privado. Si usas un objeto anónimo como tipo de retorno de una función pública o como tipo de una propiedad pública, el tipo real de esa función o propiedad será el supertipo declarado del objeto anónimo; si no declaras ningún supertipo, será Any. Los miembros agregados en el objeto anónimo no serán accesibles.

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”
    }
}

En las expresiones de objeto se puede acceder fácilmente a otras variables del ámbito:

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++
        }
    })
    // ……
}

Declaración de objeto

Kotlin usa la palabra clave `object` para declarar un objeto.

En Kotlin, podemos obtener fácilmente un singleton mediante declaraciones de objeto.

object DataProviderManager {
    fun registerDataProvider(provider: DataProvider) {
        // ……
    }

    val allDataProviders: Collection<DataProvider>
        get() = // ……
}

Para referenciar este objeto, simplemente usamos su nombre:

DataProviderManager.registerDataProvider(……)

Por supuesto, también puedes definir una variable para obtener este objeto, pero cuando defines dos variables diferentes para obtener este objeto, descubrirás que no puedes obtener dos variables distintas. Es decir, de esta manera obtenemos un singleton.

var data1 = DataProviderManager
var data2 = DataProviderManager
data1.name = "test"
print("data1 name = ${data2.name}")  

Ejemplo

En el siguiente ejemplo, ambos objetos imprimen la misma URL:

object Site {
    var url:String = ""
    val name: String = "Ejemplo"
}
fun main(args: Array<String>) {
    var s1 =  Site
    var s2 = Site
    s1.url = "www.example.com"
    println(s1.url)
    println(s2.url)
}

El resultado es:

www.example.com
www.example.com

Un objeto puede tener supertipos:

object DefaultListener : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) {
        // ……
    }

    override fun mouseEntered(e: MouseEvent) {
        // ……
    }
}

A diferencia de las expresiones de objeto, cuando una declaración de objeto se encuentra dentro de otra clase, ese objeto no puede ser accedido mediante una instancia de la clase externa, sino solo mediante el nombre de la clase. Además, ese objeto tampoco puede acceder directamente a los métodos y variables de la clase externa.

class Site {
    var name = "Ejemplo"
    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 // 正确
}

Objeto complementario

Una declaración de objeto dentro de una clase se puede marcar con la palabra clave `companion`, de modo que quede asociada a la clase externa, y así podemos acceder directamente a los elementos internos del objeto a través de la clase externa.

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

val instance = MyClass.create()   // 访问到对象的内部元素

Podemos omitir el nombre del objeto y usar `Companion` para reemplazar el nombre que se declararía:

class MyClass {
    companion object {
    }
}

val x = MyClass.Companion

Nota:En una clase solo se puede declarar un objeto interno asociado, es decir, la palabra clave `companion` solo se puede usar una vez.

Los miembros de un objeto complementario parecen miembros estáticos de otros lenguajes, pero en tiempo de ejecución siguen siendo miembros de instancia de un objeto real. Por ejemplo, también pueden implementar interfaces:

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


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

Diferencias semánticas entre expresiones de objeto y declaraciones de objeto

Hay una diferencia semántica importante entre las expresiones de objeto y las declaraciones de objeto:

  • Las expresiones de objeto se ejecutan inmediatamente en el lugar donde se usan.

  • Las declaraciones de objeto se inicializan de forma diferida (perezosa) cuando se accede a ellas por primera vez.

  • La inicialización del objeto complementario ocurre cuando la clase correspondiente se carga (resuelve), lo que coincide con la semántica de los inicializadores estáticos de Java.

Otras extensiones