object en Kotlin: sintaxis y uso práctico de objetos singleton

¿Qué es object en Kotlin?

object en Kotlin es una forma de declaración especial que simultáneamente define una clase y crea su única instancia (singleton). Es un híbrido de declaración de clase y creación de instancia en una sola construcción.

En Java, crear un singleton requiere un constructor privado, un campo estático, un método getInstance y manejo de seguridad de hilos. Kotlin object hace esto en una sola línea de código: object MySingleton { }. El compilador genera automáticamente una inicialización perezosa thread-safe utilizando el mecanismo static initializer en bytecode JVM.

Según la Especificación del lenguaje Kotlin (2026), object declaration se compila en una clase final con un constructor privado y un campo estático INSTANCE inicializado en un bloque estático. Esto garantiza la atomicidad de la inicialización a nivel de JVM.

Objetos singleton (object declaration)

Object declaration (objeto singleton) se declara usando la palabra clave object seguida de un nombre. El cuerpo del objeto puede contener propiedades, métodos, bloques init y heredar otras clases o interfaces.

object DatabaseManager {
    private val connection: String = "jdbc:postgresql://localhost:5432/app"
    
    fun query(sql: String): List<Map<String, Any>> {
        // ejecutando la consulta
        return emptyList()
    }
}

// Uso
DatabaseManager.query("SELECT * FROM users")

La inicialización de DatabaseManager ocurre en el primer acceso — de forma perezosa y thread-safe. No se requiere código de sincronización adicional.

Herencia para object

Object puede heredar clases e interfaces regulares. Esto permite usar object como implementación de una clase abstracta o interfaz con una única instancia.

interface Logger {
    fun log(message: String)
}

object ConsoleLogger : Logger {
    override fun log(message: String) {
        println("[LOG] $message")
    }
}

Companion object

companion object es un objeto especial declarado dentro de una clase con la palabra clave companion. Reemplaza los miembros estáticos en Kotlin, ya que el lenguaje no tiene la palabra clave static.

class ApiClient {
    companion object {
        private const val BASE_URL = "https://api.example.com"
        
        fun create(): ApiClient {
            return ApiClient()
        }
    }
}

// Llamando sin crear una instancia de ApiClient
val client = ApiClient.create()

Companion object puede tener un nombre (por defecto Companion), implementar interfaces y ser extendido mediante extension functions. A diferencia de los métodos estáticos en Java, un companion object es un objeto completo que puede pasarse como argumento o guardarse en una variable.

Según las Mejores prácticas de Kotlin (2026), companion object se utiliza para métodos fábrica, constantes y utilidades estáticas relacionadas con la clase. Se recomienda evitar el uso excesivo de companion object — para utilidades no relacionadas, es preferible usar funciones de nivel superior.

Anotación @JvmStatic

Para compatibilidad con Java, los métodos de companion object pueden anotarse con @JvmStatic. Esto genera un método estático real en bytecode JVM, accesible desde código Java sin la sintaxis Companion.

Object expressions (objetos anónimos)

Object expression es un objeto anónimo creado en el momento para sobrescribir métodos de una clase o interfaz sin declarar una clase con nombre separada.

val handler = object : Runnable {
    override fun run() {
        println("Tarea ejecutada")
    }
}

thread(handler)

Object expressions se diferencian de las declaraciones object en que crean una nueva instancia cada vez que se ejecutan. No son singletons y no tienen nombre. Los objetos anónimos pueden capturar variables de su cierre, como las lambdas.

A diferencia de Java, donde las clases anónimas pueden heredar solo un tipo, la object expression de Kotlin puede heredar múltiples tipos a la vez.

interface Clickable {
    fun click()
}

abstract class View {
    abstract fun render()
}

val button = object : View(), Clickable {
    override fun render() = println("Renderizando botón")
    override fun click() = println("Botón clickeado")
}

Casos prácticos de uso

Object es una de las construcciones más versátiles de Kotlin, utilizada en múltiples escenarios.

Singleton de Repository

En proyectos Android, object se usa a menudo para declarar un Repository donde no se necesitan múltiples instancias. Una única instancia garantiza la consistencia de los datos.

object UserRepository {
    fun getUser(id: Int): User? {
        // obteniendo el usuario
        return null
    }
}

Métodos fábrica mediante companion object

Companion object con métodos fábrica es una alternativa a múltiples constructores. Los métodos fábrica con nombre hacen que el código sea autodocumentado.

data class GsonParser {
    companion object {
        fun create(): GsonParser = GsonParser()
        fun createPretty(): GsonParser = GsonParser()
    }
}

Constantes y enumeraciones

Object puede servir como contenedor de constantes, reemplazando los campos static final de Java. Object soporta herencia, lo que permite crear jerarquías de configuración.

Según la Biblioteca estándar de Kotlin (2026), object declaration es la forma más eficiente de crear un singleton en Kotlin, superando a las implementaciones con double-checked locking y comparable al singleton con enum en Java.