Kotlin Academy · Lección

Métodos de fábrica con companion object

Implemente patrones de fábrica usando companion object y el operador invoke.

Métodos de fábrica con companion object es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

El patrón Factory Method

Los métodos de fábrica crean objetos con nombres significativos y lógica propia, ocultando la complejidad del constructor. El objeto companion de Kotlin es el lugar ideal para definirlos.

Constructor privado + factoría

Haga privado el constructor y proporcione métodos de fábrica mediante el objeto companion.

class Token private constructor(val value: String) {
    companion object {
        fun generate() = Token(java.util.UUID.randomUUID().toString())
        fun fromString(s: String) = Token(s.trim())
    }
}
val t = Token.generate()

Métodos de fábrica con nombre

Los nombres descriptivos dejan clara la intención, a diferencia de las sobrecargas del constructor.

class Duration private constructor(val ms: Long) {
    companion object {
        fun ofMillis(ms: Long) = Duration(ms)
        fun ofSeconds(s: Long) = Duration(s * 1000)
        fun ofMinutes(m: Long) = Duration(m * 60_000)
    }
}
val d = Duration.ofMinutes(5)

Devolver null desde una factoría

Las factorías pueden devolver null para las entradas no válidas en lugar de lanzar una excepción.

class Percentage private constructor(val value: Int) {
    companion object {
        fun of(value: Int): Percentage? {
            return if (value in 0..100) Percentage(value) else null
        }
    }
}
val p = Percentage.of(75) ?: error("Invalid")

Instancias en caché

Las factorías pueden almacenar instancias en caché y reutilizarlas.

class Direction private constructor(val name: String) {
    companion object {
        private val cache = mutableMapOf<String, Direction>()
        fun of(name: String) = cache.getOrPut(name.uppercase()) {
            Direction(name.uppercase())
        }
    }
}

El operador invoke como factoría similar a un constructor

Defina invoke() para llamar a la clase como si fuera una función.

class Email private constructor(val address: String) {
    companion object {
        operator fun invoke(raw: String): Email {
            require("@" in raw) { "Invalid email" }
            return Email(raw.lowercase())
        }
    }
}
val e = Email("Test@Example.com")  // looks like a constructor

Factoría abstracta con clases sealed

Combine métodos de fábrica con jerarquías de clases sealed para crear objetos con tipos definidos.

sealed class Shape {
    data class Circle(val r: Double) : Shape()
    data class Rect(val w: Double, val h: Double) : Shape()
    companion object {
        fun circle(r: Double) = Circle(r)
        fun rect(w: Double, h: Double) = Rect(w, h)
    }
}

Factoría consciente de las dependencias

Las factorías pueden aceptar dependencias y conectarlas entre sí.

class Repository(private val db: Database) {
    companion object {
        fun create(db: Database = Database.instance) = Repository(db)
    }
    fun findAll() = db.query("SELECT * FROM items")
}

Factorías en pruebas

Los métodos de fábrica permiten crear objetos de prueba de forma clara y explícita.

class Order private constructor(
    val id: Long, val items: List<String>, val paid: Boolean
) {
    companion object {
        fun unpaid(id: Long, items: List<String>) = Order(id, items, false)
        fun paid(id: Long, items: List<String>) = Order(id, items, true)
    }
}

Desde JSON o configuración

Las factorías son puntos de entrada naturales para el análisis sintáctico.

class AppConfig private constructor(
    val baseUrl: String, val timeout: Int
) {
    companion object {
        fun fromEnv() = AppConfig(
            baseUrl = System.getenv("BASE_URL") ?: "http://localhost",
            timeout = System.getenv("TIMEOUT")?.toInt() ?: 30
        )
    }
}

Cuándo NO utilizar un constructor privado

No haga privados los constructores solo por estilo. Hágalo cuando sea necesaria la validación, se necesite almacenamiento en caché o existan varias vías de creación con semánticas distintas.

Comprobación rápida

¿Qué función operador permite llamar a un objeto companion como a un constructor: Email("a@b.com")?

Resumen

Los métodos de fábrica en objetos companion combinan un constructor privado con factorías con nombre, devoluciones opcionales de null, almacenamiento en caché e invoke() para una sintaxis similar a la de un constructor. Las factorías hacen que la creación de objetos sea segura, expresiva y fácil de probar.

Preguntas frecuentes

¿La lección «Métodos de fábrica con companion object» es gratis?

Sí — el texto completo de «Métodos de fábrica con companion object» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Métodos de fábrica con companion object»?

Implemente patrones de fábrica usando companion object y el operador invoke. Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Métodos de fábrica con companion object»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Declaración object: singletons de Kotlin
companion object: miembros similares a los estáticos en Kotlin
Objetos anónimos y expresiones de objeto
Métodos de fábrica con companion object

← Volver a Kotlin Academy