lateinit et initialisation différée
Utilisez lateinit pour les propriétés affectées ultérieurement et by lazy pour les calculs différés.
lateinit et initialisation différée 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.
Deux outils pour l’initialisation différée
Parfois, vous ne pouvez pas initialiser une propriété au moment de la construction. Kotlin fournit lateinit (pour une var affectée ultérieurement) et by lazy (pour une val calculée lors du premier accès).
Principes de lateinit
lateinit var reporte l’initialisation. La variable doit être une var non nullable et non primitive. Un accès avant l’affectation lève UninitializedPropertyAccessException.
class Service {
lateinit var name: String
fun init(value: String) { name = value }
}
fun main() {
val s = Service()
s.init("MyService")
println(s.name)
}Pourquoi utiliser lateinit ?
Utilisez lateinit pour l’injection de dépendances, les appareils de test ou les cycles de vie gérés par un framework (vues Android, beans Spring), lorsque l’initialisation a lieu en dehors du constructeur.
class Repository {
lateinit var db: String // assigned later by DI framework
fun query() = "querying $db"
}
fun main() {
val r = Repository()
r.db = "postgres://localhost"
println(r.query())
}Vérification avec isInitialized
Vous pouvez vérifier si une propriété lateinit a été affectée à l’aide de ::propName.isInitialized.
class Foo {
lateinit var bar: String
fun status() = if (::bar.isInitialized) "set to $bar" else "unset"
}
fun main() {
val f = Foo()
println(f.status()) // unset
f.bar = "hi"
println(f.status())
}Restrictions de lateinit
Vous ne pouvez pas utiliser lateinit avec des types primitifs (entiers, booléens, etc.), des types nullables ou val. Le compilateur impose ces règles.
// VALID:
lateinit var name: String
// INVALID:
// lateinit var count: Int // primitives not allowed
// lateinit val constant: String // val not allowed
// lateinit var maybe: String? // nullable not allowed
fun main() { name = "ok"; println(name) }Principes de by lazy
by lazy reporte l’initialisation d’une val jusqu’au premier accès. La lambda est exécutée une seule fois et le résultat est mis en cache.
val expensive: String by lazy {
println("Computing...")
"result"
}
fun main() {
println(expensive) // Computing... then result
println(expensive) // result (cached)
}Pourquoi utiliser by lazy ?
Utilisez by lazy lorsque l’initialisation est coûteuse et pourrait ne pas être nécessaire (mettez-la en cache pour une utilisation ultérieure), ou lorsqu’elle dépend d’autres propriétés déjà construites.
class Config {
val parsed: Map<String, String> by lazy {
println("parsing config...")
mapOf("host" to "localhost", "port" to "8080")
}
}
fun main() {
val c = Config()
println("config object created — not parsed yet")
println(c.parsed["host"]) // now parses
println(c.parsed["port"]) // cached
}Modes de sécurité des threads de lazy
Par défaut, by lazy utilise LazyThreadSafetyMode.SYNCHRONIZED. Utilisez PUBLICATION pour une initialisation concurrente acceptable, et NONE pour de meilleures performances dans un contexte mono-thread.
val safe: String by lazy { "thread-safe" }
val fast: String by lazy(LazyThreadSafetyMode.NONE) { "fast, single-thread" }
fun main() {
println(safe)
println(fast)
}lateinit ou lazy
lateinit : var affectée de l’extérieur. by lazy : val calculée par la propriété elle-même lors du premier accès.
class Demo {
lateinit var injected: String // assigned by caller
val computed: String by lazy { "computed once" }
}
fun main() {
val d = Demo()
d.injected = "from outside"
println(d.injected)
println(d.computed)
}Lire d’autres propriétés avec lazy
Une propriété lazy peut lire d’autres propriétés (initialisées précédemment) et les combiner.
class User(val first: String, val last: String) {
val fullName: String by lazy { "$first $last" }
}
fun main() {
val u = User("Ada", "Lovelace")
println(u.fullName)
}Schéma pratique
Combinez lateinit pour l’injection de dépendances et by lazy pour l’état dérivé dans la même classe.
class App {
lateinit var config: Map<String, String>
val host: String by lazy { config["host"] ?: "localhost" }
}
fun main() {
val app = App()
app.config = mapOf("host" to "api.example.com")
println(app.host) // api.example.com
}Vérification rapide
Quel mot-clé reporte l’initialisation d’une propriété val jusqu’au premier accès ?
Récapitulatif
Utilisez lateinit var pour les propriétés mutables non nulles affectées ultérieurement par des frameworks ou l’injection de dépendances. Utilisez val by lazy pour les valeurs en lecture seule qui doivent être calculées une seule fois lors du premier accès. Vérifiez l’état avec ::prop.isInitialized.
Questions Fréquemment Posées
La leçon « lateinit et initialisation différée » est-elle gratuite ?
Oui — le texte complet de « lateinit et initialisation différée » 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 « lateinit et initialisation différée » ?
Utilisez lateinit pour les propriétés affectées ultérieurement et by lazy pour les calculs différés. 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 « lateinit et initialisation différée » ?
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
- Constructeur primaire et paramètres de propriétés
- Blocs init et ordre d’initialisation
- Accesseurs get et set personnalisés avec field
- lateinit et initialisation différée