Android Academy · Leçon

Fonctions et lambdas

Définissez des fonctions avec des paramètres et des types de retour, utilisez des arguments par défaut et nommés, puis écrivez des expressions lambda concises.

Fonctions et lambdas est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. 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 3 leçons au total.

Pourquoi utiliser des fonctions ?

Les fonctions vous permettent d’écrire un bloc de code une seule fois et de le réutiliser n’importe où.

Réduire les répétitions
Rendre le code plus facile à lire et à tester
Diviser les problèmes complexes en éléments plus petits

Dans Kotlin, les fonctions sont des éléments de première classe : vous pouvez les stocker dans des variables et les transmettre.

Syntaxe de base des fonctions

Une fonction Kotlin utilise le mot-clé fun :

fun greet(name: String): String {
    return "Hello, $name!"
}

fun main() {
    val msg = greet("Alice")
    println(msg)  // Hello, Alice!

    println(greet("Bob"))  // Hello, Bob!
}

Fonctions à expression unique

Lorsque le corps d’une fonction est une expression unique, vous pouvez utiliser = et omettre les accolades ainsi que return :

fun square(n: Int): Int = n * n

fun add(a: Int, b: Int) = a + b  // type inferred

fun main() {
    println(square(5))   // 25
    println(add(3, 7))   // 10
}

Arguments par défaut et nommés

Les fonctions Kotlin prennent en charge les valeurs de paramètres par défaut : il n’est pas nécessaire d’utiliser des surcharges :

Par défaut : fun greet(name: String = "World")
Nommé : appelez avec greet(name = "Alice") pour ignorer l’ordre positionnel

Arguments par défaut et nommés en action

Les arguments par défaut permettent de conserver une API claire :

fun buildProfile(
    name: String,
    age: Int = 0,
    role: String = "User"
): String {
    return "$name | age=$age | $role"
}

fun main() {
    println(buildProfile("Alice"))
    println(buildProfile("Bob", age = 30))
    println(buildProfile("Carol", 25, "Admin"))
}

Que sont les lambdas ?

Une lambda est une fonction anonyme, c’est-à-dire une fonction sans nom.

Syntaxe : { params -> body }
Stockée dans une variable : val double = { x: Int -> x * 2 }
Transmise à une autre fonction comme argument

Les lambdas sont omniprésentes dans Android : écouteurs de clic, transformations de listes et coroutines.

Exemples de lambdas

Stockez et appelez les lambdas comme des fonctions classiques :

fun main() {
    val double = { x: Int -> x * 2 }
    println(double(4))   // 8

    val add = { a: Int, b: Int -> a + b }
    println(add(3, 5))   // 8

    // Lambda with no params
    val sayHi = { println("Hi!") }
    sayHi()              // Hi!
}

Fonctions d’ordre supérieur

Une fonction d’ordre supérieur prend une autre fonction comme paramètre ou en renvoie une.

La bibliothèque standard de Kotlin en regorge : filter, map, forEach.

Syntaxe de lambda finale : lorsque le dernier argument est une lambda, placez-la à l’extérieur des parenthèses.

Syntaxe de lambda finale

Transmettez une lambda comme dernier argument, à l’extérieur des parenthèses :

fun applyTwice(n: Int, operation: (Int) -> Int): Int {
    return operation(operation(n))
}

fun main() {
    val result = applyTwice(3) { x -> x * 2 }
    println(result)  // 12  (3 * 2 = 6, 6 * 2 = 12)

    // 'it' is the implicit single parameter
    val doubled = applyTwice(5) { it + it }
    println(doubled) // 20
}

Vérification rapide

Observez ce code. Qu’affichera-t-il ?

val triple = { x: Int -> x * 3 } println(triple(4))

Récapitulatif : fonctions et lambdas

Vous avez appris :

fun définit une fonction avec des paramètres et un type de retour
Les fonctions à expression unique utilisent la forme abrégée =
Les arguments par défaut et nommés remplacent les surcharges
Les lambdas sont des fonctions anonymes : { params -> body }
Les fonctions d’ordre supérieur acceptent des fonctions comme paramètres

Ensuite : contrôler le flux du programme avec des conditions et des boucles.

Questions Fréquemment Posées

La leçon « Fonctions et lambdas » est-elle gratuite ?

Oui — le texte complet de « Fonctions et lambdas » 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 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Fonctions et lambdas » ?

Définissez des fonctions avec des paramètres et des types de retour, utilisez des arguments par défaut et nommés, puis écrivez des expressions lambda concises. 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 2 sur 3.

Combien de temps prend la leçon « Fonctions et lambdas » ?

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