Kotlin Academy · Leçon

Types nullable et non nullable

Les bases du système de types

Types nullable et non nullable est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Pourquoi la nullabilité est importante

Le tristement célèbre NullPointerException a fait planter d'innombrables programmes. Kotlin s'attaque directement à ce problème en intégrant la nullabilité au système de types.

Dans Kotlin, le compilateur sait si une valeur peut être null ou non, et vous oblige à gérer cette possibilité avant que des problèmes ne surviennent.

Types non nuls

Par défaut, chaque type Kotlin est non nul. Une variable de type String ne peut jamais contenir null.

Cette garantie est vérifiée lors de la compilation ; vous pouvez donc utiliser librement la valeur sans effectuer de vérification.

fun main() {
    val name: String = "Alice"
    println(name.length)
}

L'affectation de null est refusée

Si vous essayez de placer null dans un type non nul, le compilateur vous arrête immédiatement.

La ligne ci-dessous ne compilerait pas, car String n'accepte pas null :

val name: String = null → erreur

fun main() {
    val city: String = "Paris"
    // val broken: String = null // compile error
    println(city)
}

Types pouvant être nuls

Pour autoriser null, ajoutez un point d'interrogation après le type : String?.

Il s'agit d'un type nullable. Il peut contenir soit une valeur réelle, soit null.

fun main() {
    val maybeName: String? = null
    println(maybeName)
}

Nullable ou non nul

Les deux déclarations se ressemblent presque, mais leur comportement est très différent :

val a: String → jamais nul
val b: String? → peut être nul

Le simple ? modifie tout le contrat de la variable.

fun main() {
    val a: String = "hi"
    val b: String? = "hi"
    println(a)
    println(b)
}

Le compilateur protège l'accès aux valeurs nullables

Vous ne pouvez pas appeler directement des méthodes sur une valeur nullable. Le compilateur refuse, car la valeur peut être null.

La ligne commentée ci-dessous ne compilerait pas :

maybe.length sur un String? → erreur

fun main() {
    val maybe: String? = "text"
    // println(maybe.length) // compile error
    println(maybe)
}

Vérifier la valeur null

Une manière simple d'utiliser une valeur nullable consiste à effectuer une vérification explicite avec if.

À l'intérieur du bloc if, Kotlin sait que la valeur n'est pas nulle et vous permet de l'utiliser en toute sécurité.

fun main() {
    val maybe: String? = "hello"
    if (maybe != null) {
        println(maybe.length)
    }
}

null dans les paramètres de fonction

Les types des paramètres suivent également cette règle. Un paramètre de type String doit recevoir une vraie valeur, tandis que String? accepte null.

Les signatures de fonction indiquent ainsi clairement ce qu'elles acceptent.

fun greet(name: String?) {
    if (name != null) {
        println("Hello, " + name)
    } else {
        println("Hello, guest")
    }
}

fun main() {
    greet("Mia")
    greet(null)
}

Types de retour pouvant être nuls

Les fonctions peuvent renvoyer des types nullables pour indiquer qu'un résultat peut être absent.

L'appelant est alors obligé de gérer le null éventuel avant d'utiliser le résultat.

fun firstChar(text: String?): Char? {
    if (text == null || text.isEmpty()) return null
    return text[0]
}

fun main() {
    println(firstChar("Kotlin"))
    println(firstChar(null))
}

Inférence par défaut

Lorsque vous affectez un littéral, Kotlin infère automatiquement un type non nul.

val n = "text" → String inféré

Pour le rendre nullable, vous devez déclarer explicitement le type avec ?.

fun main() {
    val n = "text" // inferred String (non-null)
    val m: String? = "text" // explicit nullable
    println(n.length)
    println(m)
}

Tout mettre en pratique

Le système de types répartit les valeurs en deux groupes clairs :

Non nul : toujours sûr à utiliser
Nullable : doit être traité avant utilisation

Cette distinction transforme les problèmes de nullité, qui provoquaient auparavant des plantages à l'exécution, en erreurs de compilation.

fun main() {
    val safe: String = "always here"
    val risky: String? = null
    println(safe.uppercase())
    if (risky != null) println(risky.uppercase()) else println("no value")
}

Vérification rapide

Testez votre compréhension des types nullable et non nul.

Récapitulatif

Vous avez appris les fondements de la sécurité vis-à-vis de la nullabilité dans Kotlin :

Chaque type est non nul par défaut
L'ajout de ? crée un type nullable
Le compilateur bloque l'accès dangereux aux valeurs nullables
Une vérification if (x != null) vous permet d'utiliser la valeur en toute sécurité

Vous allez maintenant découvrir les opérateurs concis qui facilitent l'utilisation des valeurs nullables.

Questions Fréquemment Posées

La leçon « Types nullable et non nullable » est-elle gratuite ?

Oui — le texte complet de « Types nullable et non nullable » 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 « Types nullable et non nullable » ?

Les bases du système de types 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 1 sur 4.

Combien de temps prend la leçon « Types nullable et non nullable » ?

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

← Retour à Kotlin Academy