Kotlin Academy · Leçon

Types de plateforme

Nullabilité issue de Java

Types de plateforme 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.

Kotlin rencontre Java

Kotlin s’exécute sur la JVM et appelle constamment du code Java. Mais Java ne connaît pas la distinction entre les types pouvant être nuls et les types non nuls.

Alors, comment Kotlin gère-t-il une valeur provenant de Java ? Grâce aux types de plateforme.

Qu’est-ce qu’un type de plateforme

Un type de plateforme est un type que Kotlin reçoit de Java et dont la nullabilité est inconnue.

Kotlin l’écrit sous la forme String! dans les messages d’erreur. Le point d’exclamation signifie que la valeur peut être nulle ou non nulle : Kotlin n’impose aucun choix.

Vérification assouplie

Pour les types de plateforme, Kotlin assouplit ses vérifications de nullabilité. Vous pouvez traiter la valeur comme non nulle sans obtenir d’erreur du compilateur.

Le compromis : si elle est réellement nulle, vous obtenez une NullPointerException à l’exécution.

Vous choisissez le type

Lorsque vous stockez une valeur de type plateforme, vous décidez comment la typer :

comme valeur non nulle String → pratique, mais risqué
comme valeur pouvant être nulle String? → sûr et explicite

Cet exemple Kotlin simule ce choix.

fun fromJava(): String? = "value from Java"

fun main() {
    val safe: String? = fromJava()
    println(safe?.length)
}

Le choix risqué

Si vous supposez que la valeur n’est pas nulle alors que la source renvoie null, le plantage se produit lors de l’affectation ou de la première utilisation.

C’est le danger caché des types de plateforme.

fun fromJava(): String? = null

fun main() {
    try {
        val risky: String = fromJava()!!
        println(risky.length)
    } catch (e: NullPointerException) {
        println("Null came from the Java side")
    }
}

Les annotations sont utiles

Les bibliothèques Java peuvent utiliser des annotations comme @Nullable et @NotNull.

Lorsqu’elles sont présentes, Kotlin en tient compte et vous fournit un véritable String? ou String au lieu d’un type de plateforme.

Bonne pratique : supposer la nullabilité

Lorsque vous appelez du code Java sans annotation, le réflexe sûr consiste à traiter le résultat comme pouvant être nul.

Déclarez votre variable avec ? et utilisez des appels sécurisés, comme pour toute valeur Kotlin pouvant être nulle.

fun fromJava(): String? = "data"

fun main() {
    val value: String? = fromJava()
    val length = value?.length ?: 0
    println(length)
}

Des frontières défensives

Traitez la frontière avec Java comme non fiable. Validez les valeurs ou fournissez-leur une valeur par défaut dès leur entrée dans votre code Kotlin.

Après cela, le reste de votre code fonctionne avec des types Kotlin propres.

fun fromJava(): String? = null

fun main() {
    val name = fromJava() ?: "default"
    // from here on, name is a clean non-null String
    println(name.uppercase())
}

Pourquoi Kotlin autorise cela

Kotlin pourrait rendre chaque valeur Java nullable, mais cela rendrait l’interopérabilité avec Java inutilement verbeuse.

Les types de plateforme sont un compromis pragmatique : ils offrent la commodité tout en vous laissant la possibilité d’être strict.

Repérer les types de plateforme

Vous n’écrirez jamais vous-même String!. Cette notation apparaît uniquement dans les indications de l’environnement de développement intégré et les messages d’erreur lorsque vous survolez des valeurs provenant de Java.

Voir le ! vous invite à décider délibérément de la nullabilité.

Assembler le tout

Les types de plateforme font le lien entre Java et Kotlin :

Leur nullabilité est inconnue et s’affiche sous la forme Type!
Kotlin vous laisse choisir entre un type pouvant être nul et un type non nul
En cas de doute, supposez que la valeur peut être nulle pour rester prudent
Les annotations éliminent les suppositions

fun fromJava(): String? = "safe value"

fun main() {
    val value: String? = fromJava()
    println(value?.uppercase() ?: "missing")
}

Vérification rapide

Vérifiez votre compréhension des types de plateforme.

Récapitulatif

Vous avez appris comment la nullabilité franchit la frontière avec Java :

Les types de plateforme ont une nullabilité inconnue
Kotlin assouplit les vérifications, mais une mauvaise hypothèse provoque un NPE à l’exécution
Supposez que les valeurs peuvent être nulles et fournissez des valeurs par défaut à la frontière
Les annotations Java rétablissent des types corrects

Cela conclut l’exploration approfondie de la sécurité face aux valeurs nulles.

Questions Fréquemment Posées

La leçon « Types de plateforme » est-elle gratuite ?

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

Nullabilité issue de Java 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 « Types de plateforme » ?

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