Réponse.

L'opérateur as en Kotlin est utilisé pour la conversion explicite des types (cast). Il existe deux variantes : as et as ?. L'un génère une exception, l'autre est plus sûr. Cet outil est important pour travailler avec le polymorphisme, ainsi que pour la migration de données et l'interaction avec les API externes.

Historique de la question

En Java, lors de la conversion des types, on utilise l'opérateur cast (TargetType)obj, qui échoue avec une ClassCastException en cas d'erreur. Kotlin a développé ce concept en ajoutant le cast sécurisé (as ?), ce qui a permis de gérer plus facilement et explicitement la nullabilité et les erreurs d'exécution.

Problème

Le casting strict des types dans un grand projet est dangereux : si le type ne correspond pas, le programme se termine de manière inattendue (ClassCastException). Il est nécessaire de minimiser ce comportement sans erreurs silencieuses ou NPE. Il est important de bien distinguer les situations où une erreur doit être traitée et celles où il est correct de simplement retourner null.

Solution

Kotlin fournit deux opérateurs :

as : conversion de type stricte, en cas de non-correspondance des types, entraîne une ClassCastException.
as ? : conversion sécurisée — retourne null si le cast est impossible.

Exemple de code :

val x: Any = "Hello, Kotlin!"

val s1: String = x as String     // Ok, x est String
val s2: String? = x as? String  // Ok, x est String
val n: Int? = x as? Int         // n = null, cast sécurisé

Caractéristiques clés :

as génère une ClassCastException en cas d'erreur.
as ? retourne null, minimisant les erreurs fatales.
Dans les structures génériques, des subtilités peuvent apparaître en raison de l'effacement de type.

Questions pièges.

L'opérateur 'as' vérifie-t-il toujours le type à l'exécution ?

Oui, si le cast se produit avec des types incompatibles, cela entraînera une ClassCastException. Cependant, pour certaines conversions implicites, par exemple entre Int et Float, ce type de conversion n'a pas lieu — la conversion idiomatique en Kotlin se fait par des méthodes (toInt, toFloat).

Peut-on utiliser 'as' avec un type nullable en un type non-nullable ?

Oui, mais soyez prudent : si la valeur est null, une exception sera générée. Tout cast d'un type nullable à un type non-nullable sans vérification peut conduire à une erreur d'exécution.

val x: String? = null
val y: String = x as String // générera une ClassCastException !

Quelle est la différence entre 'is' et 'as' ?

'is' est un opérateur de vérification de type. Il retourne true/false, ne change pas le type. 'as' effectue un changement de type, et si cela échoue, il génère une exception (ou retourne null lors de l'utilisation de 'as ?'). Ils sont souvent utilisés ensemble pour des conversions sûres :

if (x is String) {
  val s: String = x // conversion intelligente
}

Erreurs typiques et anti-modèles

Utilisation irréfléchie de as sans vérification de type, ce qui entraîne une ClassCastException.
Utilisation de cast non sécurisé lorsque la nullabilité n'est pas prise en compte.
Utilisation de cast pour transformer des types incompatibles, ce qui entraîne des erreurs d'exécution.

Exemple de la vie réelle

Cas négatif

Dans le module de parsing de données, tous les objets sont analysés via as, par exemple, obj as Double. Si les données sont erronées, l'application plante avec une ClassCastException.

Avantages :

Traitement rapide du bon format de données.

Inconvénients :

Arrêt brutal du processus à la première erreur.
Difficile à déboguer.

Cas positif

Utilise la construction smart-cast (via is) ou un cast sécurisé (as ?) :

val price = (obj as? Double) ?: 0.0