Entretien Kotlin : top questions et réponses pour réussir

Comment réussir un entretien Kotlin : les questions les plus fréquentes

Kotlin s'est solidement imposé comme le langage principal pour le développement Android et est activement utilisé dans le backend (Ktor, Spring Boot). Un entretien pour un poste de développeur Kotlin ne teste pas seulement la syntaxe, mais aussi la compréhension de la philosophie du langage : null safety, coroutines, approche fonctionnelle. Dans cet article, nous avons analysé les questions les plus courantes posées lors des entretiens, avec des exemples de code et des explications.

1. Null Safety : comment Kotlin lutte contre les NullPointerException

L'un des principaux avantages de Kotlin est la protection intégrée contre null. Contrairement à Java, où toute référence peut être null, en Kotlin, les types sont divisés en nullable et non-null.

Question : quelle est la différence entre ? et !! ?

? est l'opérateur d'appel sécurisé. Si l'objet est null, l'appel à la méthode ou à la propriété retourne simplement null sans exception.

val name: String? = nullval length = name?.length  // null, pas d'erreur

!! est l'assertion non-null. Vous garantissez que la valeur n'est pas null. Si elle est null, une NullPointerException est levée.

val length = name!!.length  // NPE si name == null

Question : qu'est-ce que l'opérateur Elvis ?: ?

Il permet de définir une valeur par défaut si la valeur à gauche est null.

val name: String? = nullval display = name ?: "Invité"

Question : comment fonctionne let avec les types nullable ?

let ne s'exécute que si l'objet n'est pas null. C'est une manière idiomatique de traiter les nullable.

name?.let {     println("Nom : $it")}

2. Coroutines : l'asynchrone sans douleur

Les coroutines sont des threads légers qui permettent d'écrire du code asynchrone dans un style impératif. Lors des entretiens, on vérifie la compréhension des scopes, des dispatchers et des fonctions suspend.

Question : quelle est la différence entre launch et async ?

• launch — lance une coroutine, retourne un Job. Ne retourne pas de résultat.
• async — lance une coroutine, retourne un Deferred (analogue à Future). Le résultat est obtenu via .await().

coroutineScope {    val job = launch { delay(100) }    val deferred = async { 42 }    val result = deferred.await()  // 42}

Question : qu'est-ce que CoroutineContext et les dispatchers ?

CoroutineContext est un ensemble d'éléments qui définissent le comportement de la coroutine (dispatcher, Job, nom). Les dispatchers principaux sont :

• Dispatchers.Main — pour l'UI (Android).
• Dispatchers.IO — pour les entrées/sorties (réseau, fichiers).
• Dispatchers.Default — pour les tâches intensives en CPU.

Question : qu'est-ce que withContext ?

Permet de changer de dispatcher à l'intérieur d'une coroutine sans changer le scope.

suspend fun loadData(): String = withContext(Dispatchers.IO) {    // opération longue    "Données"}

3. Classes et objets : sealed, data, companion

Kotlin propose plusieurs types de classes spéciales qui simplifient les patterns typiques.

Question : qu'est-ce qu'une sealed class et quand l'utiliser ?

Une sealed class est une classe abstraite avec un ensemble limité de sous-classes. Tous les héritiers sont connus à la compilation. Idéale pour représenter des états (UI State) ou des résultats d'opérations.

sealed class Result {    data class Success(val data: String) : Result()    data class Error(val message: String) : Result()    object Loading : Result()}

fun handleResult(result: Result) {    when (result) {        is Result.Success -> println(result.data)        is Result.Error -> println(result.message)        Result.Loading -> println("Chargement...")    }}

La branche else n'est pas nécessaire — le compilateur connaît toutes les variantes.

Question : quelle est la différence entre une data class et une classe ord