object en Kotlin : syntaxe et utilisation pratique des objets singleton

Qu'est-ce que object en Kotlin ?

object en Kotlin est une forme de déclaration spéciale qui définit simultanément une classe et crée son unique instance (singleton). C'est un hybride de déclaration de classe et de création d'instance en une seule construction.

En Java, créer un singleton nécessite un constructeur privé, un champ statique, une méthode getInstance et une gestion de la sécurité des threads. Kotlin object fait cela en une seule ligne de code : object MySingleton { }. Le compilateur génère automatiquement une initialisation paresseuse thread-safe en utilisant le mécanisme static initializer dans le bytecode JVM.

Selon la Spécification du langage Kotlin (2026), object declaration est compilé en une classe finale avec un constructeur privé et un champ statique INSTANCE initialisé dans un bloc statique. Cela garantit l'atomicité de l'initialisation au niveau de la JVM.

Objets singleton (object declaration)

Object declaration (objet singleton) se déclare en utilisant le mot-clé object suivi d'un nom. Le corps de l'objet peut contenir des propriétés, des méthodes, des blocs init et hériter d'autres classes ou interfaces.

object DatabaseManager {
    private val connection: String = "jdbc:postgresql://localhost:5432/app"
    
    fun query(sql: String): List<Map<String, Any>> {
        // exécution de la requête
        return emptyList()
    }
}

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

L'initialisation de DatabaseManager se produit au premier accès « de manière paresseuse et thread-safe. Aucun code de synchronisation supplémentaire n'est nécessaire.

Héritage pour object

Object peut hériter de classes et d'interfaces régulières. Cela permet d'utiliser object comme implémentation d'une classe abstraite ou d'une interface avec une seule instance.

interface Logger {
    fun log(message: String)
}

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

Companion object

companion object est un objet spécial déclaré à l'intérieur d'une classe avec le mot-clé companion. Il remplace les membres statiques en Kotlin car le langage n'a pas de mot-clé static.

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

// Appel sans créer d'instance ApiClient
val client = ApiClient.create()

Companion object peut avoir un nom (par défaut Companion), implémenter des interfaces et être étendu via des extension functions. Contrairement aux méthodes statiques en Java, un companion object est un objet à part entière qui peut être passé comme argument ou stocké dans une variable.

Selon les Bonnes pratiques Kotlin (2026), companion object est utilisé pour les méthodes d'usine, les constantes et les utilitaires statiques liés à la classe. Il est recommandé d'éviter une utilisation excessive de companion object « pour les utilitaires non liés, les fonctions de niveau supérieur sont préférables.

Annotation @JvmStatic

Pour la compatibilité Java, les méthodes du companion object peuvent être annotées avec @JvmStatic. Cela génère une véritable méthode statique dans le bytecode JVM, accessible depuis le code Java sans la syntaxe Companion.

Object expressions (objets anonymes)

Object expression est un objet anonyme créé sur place pour redéfinir les méthodes d'une classe ou d'une interface sans déclarer une classe nommée séparée.

val handler = object : Runnable {
    override fun run() {
        println("Tâche exécutée")
    }
}

thread(handler)

Object expressions diffèrent des déclarations object car ils créent une nouvelle instance à chaque exécution. Ils ne sont pas des singletons et n'ont pas de nom. Les objets anonymes peuvent capturer des variables depuis leur fermeture, comme les lambdas.

Contrairement à Java, où les classes anonymes ne peuvent hériter que d'un seul type, l'object expression de Kotlin peut hériter de plusieurs types à la fois.

interface Clickable {
    fun click()
}

abstract class View {
    abstract fun render()
}

val button = object : View(), Clickable {
    override fun render() = println("Rendu du bouton")
    override fun click() = println("Bouton cliqué")
}

Cas d'utilisation pratiques

Object est l'une des constructions les plus polyvalentes de Kotlin, utilisée dans de nombreux scénarios.

Singletons de Repository

Dans les projets Android, object est souvent utilisé pour déclarer un Repository où plusieurs instances ne sont pas nécessaires. Une instance unique garantit la cohérence des données.

object UserRepository {
    fun getUser(id: Int): User? {
        // obtention de l'utilisateur
        return null
    }
}

Méthodes d'usine via companion object

Companion object avec des méthodes d'usine est une alternative aux constructeurs multiples. Les méthodes d'usine nommées rendent le code auto-documenté.

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

Constantes et énumérations

Object peut servir de conteneur pour les constantes, remplaçant les champs static final en Java. Object prend en charge l'héritage, ce qui permet de créer des hiérarchies de configuration.

Selon la Bibliothèque standard Kotlin (2026), object declaration est le moyen le plus performant de créer un singleton en Kotlin, surpassant les implémentations double-checked locking et comparable au singleton enum en Java.