Kotlin Academy · Lezione

Metodi factory con companion object

Implementi pattern factory usando companion object e l'operatore invoke.

Metodi factory con companion object è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Pattern Factory Method

I metodi factory creano oggetti con nomi e logiche significativi, nascondendo la complessità dei costruttori. Il companion object di Kotlin è il luogo ideale per definirli.

Costruttore privato e factory

Renda privato il costruttore e fornisca metodi factory tramite il companion object.

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()

Metodi factory con nome

I nomi descrittivi rendono chiara l'intenzione, a differenza degli overload del costruttore.

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)

Restituire null da una factory

Le factory possono restituire null per input non validi invece di lanciare un'eccezione.

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")

Istanze memorizzate nella cache

Le factory possono memorizzare nella cache e riutilizzare le istanze.

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())
        }
    }
}

Operatore invoke come factory simile a un costruttore

Definisca invoke() per chiamare la classe come una funzione.

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

Factory astratta con classi sealed

Combini i metodi factory con gerarchie di classi sealed per una creazione tipizzata.

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

Factory con gestione delle dipendenze

Le factory possono accettare dipendenze e configurarle.

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

Factory nei test

I metodi factory rendono la creazione degli oggetti di test chiara ed esplicita.

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

Da JSON/configurazione

Le factory sono punti di ingresso naturali per il parsing.

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

Quando NON utilizzare un costruttore privato

Non renda privati i costruttori solo per ragioni stilistiche. Lo faccia quando è necessaria la validazione, serve la memorizzazione nella cache oppure esistono più percorsi di creazione con semantiche distinte.

Verifica rapida

Quale funzione operatore consente di chiamare un companion object come un costruttore: Email("a@b.com")?

Riepilogo

Metodi factory nei companion object: costruttore privato e factory con nome, restituzione facoltativa di null, caching e invoke() per una sintassi simile a quella del costruttore. Le factory rendono la creazione degli oggetti sicura, espressiva e verificabile con i test!

Domande Frequenti

La lezione «Metodi factory con companion object» è gratuita?

Sì — il testo completo di «Metodi factory con companion object» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Metodi factory con companion object»?

Implementi pattern factory usando companion object e l'operatore invoke. Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Metodi factory con companion object»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Dichiarazione object: singleton in Kotlin
companion object: membri simili agli static in Kotlin
Oggetti anonimi ed espressioni object
Metodi factory con companion object

← Torna a Kotlin Academy