Kotlin Academy · Leçon

Méthodes fabrique avec companion object

Implémentez des fabriques à l’aide de companion object et de l’opérateur invoke.

Leçon 4 sur 413 étapes

Méthodes fabrique avec companion object est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Le patron de méthode de fabrique

Les méthodes de fabrique créent des objets avec des noms et une logique explicites, en masquant la complexité des constructeurs. L’objet compagnon de Kotlin est l’emplacement idéal pour les définir.

Constructeur privé et fabrique

Rendez le constructeur privé et fournissez des méthodes de fabrique via l’objet compagnon.

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éthodes de fabrique nommées

Des noms descriptifs rendent l’intention claire, contrairement aux surcharges de constructeur.

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)

Renvoyer null depuis une fabrique

Les fabriques peuvent renvoyer null pour les entrées invalides au lieu de lancer une exception.

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

Instances mises en cache

Les fabriques peuvent mettre en cache les instances et les réutiliser.

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

L’opérateur invoke comme fabrique semblable à un constructeur

Définissez invoke() pour appeler la classe comme une fonction.

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

Fabrique abstraite avec des classes scellées

Combinez les méthodes de fabrique avec des hiérarchies de classes scellées pour créer des objets typés.

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

Fabrique gérant les dépendances

Les fabriques peuvent accepter des dépendances et les relier automatiquement.

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

Fabrique dans les tests

Les méthodes de fabrique rendent la création d’objets de test claire et explicite.

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

Depuis JSON/Config

Les fabriques constituent des points d’entrée naturels pour l’analyse des données.

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

Quand NOT utiliser un constructeur privé

Ne rendez pas les constructeurs privés par simple souci de style. Faites-le lorsque : une validation est nécessaire, la mise en cache est requise ou plusieurs chemins de création ont des sémantiques distinctes.

Vérification rapide

Quelle fonction opérateur permet d’appeler un objet compagnon comme un constructeur : Email("a@b.com") ?

Réponds-y dans la leçon interactive

Récapitulatif

Méthodes de fabrique dans les objets compagnons : constructeur privé et fabriques nommées, retours null facultatifs, mise en cache et invoke() pour une syntaxe semblable à celle d’un constructeur. Les fabriques rendent la création d’objets sûre, expressive et facile à tester !

Gratuit pour commencer

Apprends Kotlin avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 51
Leçons: 203

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Méthodes fabrique avec companion object » est-elle gratuite ?

Oui — le texte complet de « Méthodes fabrique avec companion object » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Méthodes fabrique avec companion object » ?

Implémentez des fabriques à l’aide de companion object et de l’opérateur invoke. Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Méthodes fabrique avec companion object » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Déclaration object : singletons Kotlin
companion object : membres semblables aux membres statiques
Objets anonymes et expressions object
Méthodes fabrique avec companion object

← Retour à Kotlin Academy