Kotlin pour Android : bases de la syntaxe et fonctionnalités

Qu'est-ce que Kotlin ?

Kotlin est un langage de programmation typé statiquement créé par JetBrains (développeur d'IntelliJ IDEA) et publié en 2016 sous licence Apache 2.0. Kotlin compile en bytecode JVM, JavaScript et code natif (via Kotlin/Native). Ses principaux domaines d'application sont le développement Android, les applications serveur et les projets multiplateformes.

Google a annoncé Kotlin comme langage officiel du développement Android lors de Google I/O 2017. Selon Google (Android Developer Blog, 2026), plus de 85% des nouveaux projets sur Google Play utilisent Kotlin. Le langage est également activement utilisé dans le développement serveur (Spring Boot, Ktor) et les projets multiplateformes (Kotlin Multiplatform Mobile).

Kotlin est totalement compatible avec Java — vous pouvez appeler du code Java depuis Kotlin et vice versa dans le même projet. Les outils de build (Gradle, Maven) supportent les deux langages, permettant une migration progressive de Java vers Kotlin sans temps d'arrêt de développement.

Pourquoi Kotlin est plus populaire que Java pour Android

Les principales raisons : concision — Kotlin nécessite en moyenne 40% de lignes de code en moins que Java pour la même tâche. Null safety — le compilateur interdit l'utilisation de types nullable sans vérification. Capacités fonctionnelles — fonctions d'ordre supérieur, lambdas, fonctions d'extension et coroutines rendent le code plus expressif et plus sûr.

Bases de la syntaxe

La syntaxe de base de Kotlin allie concision et clarté. Les variables sont déclarées avec val (immuable) et var (muable). Le compilateur utilise l'inférence de types, mais la déclaration explicite de type est supportée. Les fonctions sont déclarées avec le mot-clé fun.

package com.example.intro

// Constantes et variables
val appName: String = "KotlinApp"  // immuable
var version = 1.0  // muable, type inféré

// Fonction avec expression body
fun sum(a: Int, b: Int) = a + b

// String templates
fun greet(name: String) = "Bonjour, $name ! Version ${appName}_$version"

// Default and named arguments
fun createUser(
    name: String,
    age: Int = 18,
    email: String? = null
)

L'expression when remplace switch en Java et est plus flexible : elle supporte les vérifications de type, les plages, les conditions et les branches sans break. Le compilateur vérifie la couverture exhaustive pour les classes enum et sealed. Les smart casts convertissent automatiquement les types après une vérification is, éliminant les casts explicites.

fun analyzeValue(value: Any) = when (value) {
    is String -> "Chaîne de longueur ${value.length}"  // smart cast
    is Int -> "Nombre entier : $value"
    in 1..10 -> "Nombre dans la plage 1-10"
    else -> "Type inconnu"
}

Null safety et opérateurs Elvis

Null safety est une fonctionnalité clé de Kotlin qui élimine NullPointerException à la compilation. En Kotlin, les types ne peuvent pas être null par défaut. Pour autoriser null, ajoutez ? au type : String?. Le compilateur exige une vérification explicite de chaque valeur nullable.

// Types nullable et non-null
val nonNull: String = "Toujours non null"
val nullable: String? = null  // autorisé

// Safe call — s'exécute seulement si non null
val length: Int? = nullable?.length

// Opérateur Elvis — valeur par défaut
val text: String = nullable ?: "Default text"

// Let — exécuter un bloc avec une valeur non-null
nullable?.let { value ->
    println("Valeur : $value")
}

L'opérateur safe call (?.) retourne null si l'objet avant l'opérateur est null, et appelle la méthode/propriété sinon. L'opérateur Elvis (?:) fournit une valeur par défaut si la partie gauche est null. L'assertion not-null (!!) lève NullPointerException si la valeur est null — utilisez-la seulement lorsque vous êtes sûr à 100% que la valeur existe.

Types platform — types Java issus du code Java appelé que Kotlin ne peut pas marquer comme nullable ou non-null. Le type s'affiche comme String! (avec un point d'exclamation). Le développeur est responsable de la null safety lorsqu'il travaille avec du code Java.

Data classes et déstructuration

Les data classes en Kotlin génèrent automatiquement equals(), hashCode(), toString(), copy() et componentN(). Cela élimine le boilerplate des modèles Java (POJO) et rend le code plus propre. Déclarer une data class prend une ligne au lieu de 20-30 en Java.

data class User(
    val id: Long,
    val name: String,
    val email: String,
    val age: Int? = null
)

// Utilisation
val user = User(1, "Anna", "anna@example.com")
val updatedUser = user.copy(age = 25)

// Déstructuration
val (id, name) = user
println("Utilisateur #$id : $name")

La déstructuration permet de décomposer une data class en variables en une seule ligne. C'est pratique lorsqu'on travaille avec des paires, des triplets et d'autres valeurs composites. La déstructuration est supportée pour les data classes, les collections standard (List, Map) et toute classe avec operator fun componentN().

Fonctions d'extension

Les fonctions d'extension sont un mécanisme de Kotlin pour ajouter de nouvelles méthodes à des classes existantes sans héritage. Les extensions sont compilées en méthodes statiques avec un paramètre receiver, donc l'héritage n'est pas requis et le dispatch virtuel n'est pas supporté.

// Fonction d'extension pour String
fun String.isEmail(): Boolean {
    return this.contains("@") && this.contains(".")
}

// Propriété d'extension
val String.isPhoneNumber: Boolean
    get() = this.matches(Regex("^\\+?[\\d-]{10,15}$"))

// Extension générique pour les collections
fun List<Int>.sumOfEvens(): Int {
    return this.filter { it % 2 == 0 }.sum()
}

// Utilisation
println("test@mail.com".isEmail())  // true

Les extensions sont largement utilisées dans l'Android SDK et les bibliothèques. Par exemple, les Activity extensions dans Android KTX sont des fonctions d'extension pour Activity, Fragment, View et d'autres classes. Les extensions peuvent être déclarées comme des fonctions de niveau supérieur dans un fichier ou comme des extensions membres d'une classe.

Coroutines pour la programmation asynchrone

Les coroutines sont un mécanisme de programmation asynchrone en Kotlin qui permet d'écrire du code non bloquant dans un style séquentiel. Une coroutine suspend son exécution sur une fonction suspend sans bloquer le thread et reprend après l'achèvement de l'opération. C'est une alternative aux chaînes de callbacks RxJava et à AsyncTask.

import kotlinx.coroutines.*

// Fonction suspend — peut être mise en pause
suspend fun fetchUserData(userId: Int): User {
    // delay — fonction suspend, ne bloque pas le thread
    delay(500)
    return User(userId, "User $userId", "user@example.com")
}

// Lancer dans une coroutine
fun loadData() {
    CoroutineScope(Dispatchers.Main).launch {
        val user = fetchUserData(1)  // pause ici
        updateUI(user)  // continuer sur le thread Main
    }
}

Les Dispatchers déterminent le pool de threads pour une coroutine : Dispatchers.Main (thread UI), Dispatchers.IO (opérations réseau/disque), Dispatchers.Default (tâches intensives en CPU). La concurrence structurée garantit qu'une coroutine ne reste pas active après la fin du scope — cela évite les fuites mémoire.

// Exécution parallèle via async/await
suspend fun loadDashboard(): Dashboard = coroutineScope {
    val user = async { fetchUserData(1) }
    val orders = async { fetchOrders(1) }
    val stats = async { fetchStats() }
    
    Dashboard(user.await(), orders.await(), stats.await())
}

Kotlin vs Java : comparaison

Le choix entre Kotlin et Java pour un nouveau projet Android est une décision architecturale fondamentale. Kotlin offre une syntaxe plus moderne et des mécanismes de sécurité intégrés, tandis que Java dispose d'un plus grand bassin de développeurs et de bibliothèques matures.

Performances de Kotlin et Java sont comparables — les deux compilent en bytecode JVM. Kotlin ajoute parfois un micro-overhead pour les coroutines et l'inlining, mais cela est négligeable pour les applications mobiles. Google et JetBrains investissent activement dans Kotlin : Kotlin Multiplatform, Kotlin/Wasm et les améliorations de performances du compilateur K2.