Kotlin Academy · Leçon

Fonctions et classes génériques

Paramétrer les types

Fonctions et classes génériques est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Que sont les types génériques ?

Les types génériques vous permettent d’écrire du code qui fonctionne avec de nombreux types tout en conservant une sécurité de typage complète. Au lieu de fixer un type concret, vous utilisez un paramètre de type, souvent T, comme espace réservé.

Une fonction générique

Une fonction générique déclare son paramètre de type entre chevrons avant le nom de la fonction. Ici, T peut être n’importe quel type.

fun <T> identity(value: T): T {
    return value
}

fun main() {
    println(identity(42))
    println(identity("hello"))
}

Inférence de type

Vous indiquez rarement le type explicitement : le compilateur déduit T à partir des arguments. Vous pouvez néanmoins l’écrire sous la forme identity<Int>(42) si nécessaire.

fun <T> firstOf(a: T, b: T): T = a

fun main() {
    val x = firstOf(10, 20)
    val y = firstOf("a", "b")
    println("$x $y")
}

Plusieurs paramètres de type

Une fonction peut posséder plusieurs paramètres de type, ce qui est utile pour travailler avec des paires de types sans lien entre eux.

fun <A, B> makePair(first: A, second: B): Pair<A, B> {
    return Pair(first, second)
}

fun main() {
    val p = makePair("age", 30)
    println(p)
}

Une classe générique

Les classes peuvent également être génériques. Le paramètre de type est déclaré après le nom de la classe et peut être utilisé pour les propriétés et les fonctions.

class Box<T>(val value: T) {
    fun get(): T = value
}

fun main() {
    val intBox = Box(123)
    val strBox = Box("Kotlin")
    println(intBox.get())
    println(strBox.get())
}

Une classe générique avec comportement

Les classes génériques peuvent contenir un état modifiable et agir sur le paramètre de type, comme un simple conteneur.

class Stack<T> {
    private val items = mutableListOf<T>()
    fun push(item: T) { items.add(item) }
    fun pop(): T = items.removeAt(items.size - 1)
    fun isEmpty() = items.isEmpty()
}

fun main() {
    val stack = Stack<Int>()
    stack.push(1)
    stack.push(2)
    println(stack.pop())
}

Des interfaces génériques

Les interfaces peuvent elles aussi déclarer des paramètres de type, ce qui permet aux implémentations de choisir le type concret.

interface Container<T> {
    fun item(): T
}

class StringContainer : Container<String> {
    override fun item(): String = "fixed"
}

fun main() {
    println(StringContainer().item())
}

Pourquoi ne pas utiliser n’importe quel type ?

Vous pourriez stocker les valeurs sous le type Any, mais vous perdriez les informations de type et devriez effectuer des conversions de type. Les types génériques préservent le type exact, si bien que le compilateur détecte les erreurs et qu’aucune conversion n’est nécessaire.

fun main() {
    val box: Box<String> = Box("text")
    val s: String = box.get()
    println(s.uppercase())
}

class Box<T>(val value: T) { fun get(): T = value }

Fonctions d’extension génériques

Les fonctions d’extension peuvent être génériques, ce qui permet de créer des utilitaires réutilisables pour tous les types.

fun <T> T.printAndReturn(): T {
    println("Value: $this")
    return this
}

fun main() {
    val x = 5.printAndReturn()
    "hi".printAndReturn()
    println(x)
}

Conventions de nommage

Par convention, des lettres majuscules isolées servent à nommer les paramètres de type : T pour un type générique, E pour un élément, K et V pour les clés et les valeurs d’une table associative, et R pour un résultat.

Des types génériques partout

La bibliothèque standard de Kotlin repose sur les types génériques : List<T>, Map<K, V>, Pair<A, B>. Comprendre les types génériques vous aide à lire et à utiliser ces types en toute confiance.

Vérification rapide

Quel est le principal avantage des types génériques par rapport à l’utilisation de n’importe quel type ?

Récapitulatif

Les types génériques utilisent des paramètres de type comme T pour écrire des fonctions, des classes et des interfaces réutilisables et sûres du point de vue du typage. Le compilateur déduit les types et garantit la sécurité, ce qui évite les conversions de type. Vous allez maintenant contrôler les relations entre les types génériques grâce à la variance au niveau de la déclaration avec in et out.

Questions Fréquemment Posées

La leçon « Fonctions et classes génériques » est-elle gratuite ?

Oui — le texte complet de « Fonctions et classes génériques » 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 « Fonctions et classes génériques » ?

Paramétrer les types 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 1 sur 4.

Combien de temps prend la leçon « Fonctions et classes génériques » ?

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