Android Academy · Leçon

Types pouvant être nuls ou non nuls

Le marqueur de type ?.

Types pouvant être nuls ou non nuls est une leçon Android 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 Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 4 leçons au total.

Pourquoi la sécurité vis-à-vis de null est importante

De nombreux plantages d’applications Android proviennent d’une seule erreur : utiliser une valeur qui est en réalité absente. Dans d’autres langages, cela devient une redoutable NullPointerException lors de l’exécution.

Kotlin traite ce problème lors de la compilation. Le système de types suit les valeurs qui peuvent être null et celles qui ne le peuvent jamais. Cette leçon présente les fondements de ce système.

Types non nuls

Par défaut, un type Kotlin ne peut pas contenir null. Un String désigne toujours une chaîne réelle.

Si vous essayez de lui affecter null, le code ne sera même pas compilé. C’est le comportement sûr par défaut.

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

null est refusé

Observez ce qui se passe lorsque vous essayez de placer null dans un type non nul.

Le compilateur vous arrête immédiatement. Vous n’atteignez jamais l’exécution avec un bogue dissimulé.

val name: String = null  // Compile error:
// Null can not be a value of a non-null type String

Types pouvant être nuls avec ?

Parfois, une valeur peut réellement être absente, comme le deuxième prénom facultatif d’un utilisateur. Vous l’indiquez en ajoutant ? au type.

Un String? peut contenir une chaîne réelle ou null. Le point d’interrogation indique que le type peut être nul.

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

Deux types différents

String et String? ne sont pas le même type. Le second est un type plus large qui inclut la valeur null.

C’est cette distinction qui permet au compilateur de vous protéger. Il sait exactement où null peut apparaître.

val sure: String = "hello"
val maybe: String? = "hello"
// maybe could later be null; sure never can

Vous ne pouvez pas utiliser directement une valeur pouvant être nulle

Le compilateur ne vous laissera pas appeler une méthode sur une valeur pouvant être nulle sans la vérifier au préalable.

Comme middleName pourrait être null, appeler .length dessus provoque une erreur de compilation. Vous devez gérer le cas nul.

val middleName: String? = null
println(middleName.length)
// Error: only safe (?.) or non-null (!!) calls allowed

Vérifier avec if

La manière la plus simple d’utiliser une valeur pouvant être nulle consiste à la vérifier avec une condition if.

Dans la branche où vous avez prouvé qu’elle n’est pas nulle, Kotlin la convertit intelligemment en type non nul, et .length fonctionne.

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

Conversions intelligentes

Après une vérification réussie de l’absence de valeur nulle, le compilateur se souvient que la valeur n’est pas nulle pour le reste de ce bloc. On appelle cela une conversion intelligente.

Vous n’avez écrit aucune conversion. Kotlin l’a suivie automatiquement pour vous.

fun describe(s: String?) {
    if (s == null) return
    // s is now treated as String here
    println("Length is " + s.length)
}

Paramètres de fonction

Le fait qu’un paramètre puisse être nul ou non fait partie du contrat de la fonction. Un paramètre non nul promet aux appelants qu’il ne recevra jamais null.

Un paramètre pouvant être nul indique qu’une entrée absente est prévue et gérée.

fun greet(name: String) {
    println("Hi, " + name)
}
// greet(null) would not compile

Les types de retour peuvent être nuls

Une fonction peut renvoyer null pour signaler qu’aucun élément n’a été trouvé. Marquez son type de retour avec ?.

Les appelants savent alors qu’ils doivent vérifier le résultat avant de l’utiliser.

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

Privilégier les types non nuls

Une bonne règle consiste à privilégier les types non nuls. N’ajoutez ? que lorsqu’une valeur peut réellement être absente.

Votre code reste ainsi cohérent. Moins vous avez de types pouvant être nuls, moins vous aurez de vérifications à effectuer par la suite.

// Prefer this:
val score: Int = 0
// Over this, unless null is meaningful:
val maybeScore: Int? = null

Vérification rapide

Vérifiez votre compréhension des types pouvant être nuls et des types non nuls.

Récapitulatif

Par défaut, les types Kotlin sont non nuls et refusent null lors de la compilation. Ajoutez ? pour rendre un type nullable lorsqu’une valeur peut être absente.

Vous ne pouvez pas utiliser directement une valeur nullable. Une vérification de null effectue une conversion intelligente vers un type non nul, afin que vous puissiez l’utiliser en toute sécurité. Vous allez maintenant découvrir des façons plus courtes de gérer les valeurs nullables.

Questions Fréquemment Posées

La leçon « Types pouvant être nuls ou non nuls » est-elle gratuite ?

Oui — le texte complet de « Types pouvant être nuls ou non nuls » 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 Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Types pouvant être nuls ou non nuls » ?

Le marqueur de type ?. Tu pratiques Android 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 Android Academy ?

Aucune expérience préalable n'est requise. Android 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 pouvant être nuls ou non nuls » ?

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 Android Academy ?

Oui. Chaque leçon Android 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 à Android Academy