Méthodes et classes génériques
Définissez des classes génériques avec des paramètres de type et écrivez des méthodes génériques en plaçant <T> avant le type de retour. Découvrez dans quels cas l’inférence de type est utile.
Méthodes et classes génériques est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 3 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 Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 3 leçons au total.
Présentation
Les classes génériques réutilisent une même conception pour de nombreux types, tandis que les méthodes génériques fonctionnent avec des paramètres de type, même dans des classes non génériques. Nous allons créer un petit Pair<T,U>, une méthode swap et une fabrique statique.
Pourquoi utiliser des classes génériques ?
Pourquoi rendre une classe générique ?
- Une conception, plusieurs types : cela réduit la répétition.
- Sécurité des types : les types incorrects sont détectés lors de la compilation.
- API claire : aucune conversion de type dans les valeurs de retour.
Code : Pair<T,U>
Pair<T,U> permet d’utiliser la même classe avec deux types différents. Aucune conversion de type n’est nécessaire ; l’API est claire.
public class Main {
// Simple generic data holder with two type parameters
static class Pair<T, U> {
private final T first;
private final U second;
Pair(T first, U second) { this.first = first; this.second = second; }
T first() { return first; }
U second() { return second; }
public String toString() { return "Pair(" + first + ", " + second + ")"; }
}
public static void main(String[] args) {
Pair<String, Integer> p = new Pair<>("age", 21);
System.out.println(p);
System.out.println(p.first() + " -> " + p.second());
}
}
Méthodes génériques : signature
Les méthodes génériques fonctionnent indépendamment du caractère générique de la classe. Signature : <T> returnType... Exemple : <T> T firstOrDefault(T[] arr, T def).
Code : swap générique
<T> est défini au niveau de la méthode ; celle-ci peut donc fonctionner avec différents tableaux. Nous n’avons pas indiqué le type lors de l’appel : le compilateur l’a déduit.
public class Main {
// Generic utility method: swap two indices of an array of any reference type
static <T> void swap(T[] arr, int i, int j) {
T tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp;
}
public static void main(String[] args) {
String[] names = { "Ada", "Bob", "Cyd" };
swap(names, 0, 2); // works with String[]
for (int k = 0; k < names.length; k = k + 1) {
System.out.print(names[k] + (k < names.length - 1 ? " " : "\n"));
}
}
}
Code : fabrique générique statique
Fabrique générique statique : lors de l’appel à of(T v), le type est déduit. L’utilisation est claire et lisible.
public class Main {
static class Box<T> {
private final T value;
private Box(T v) { this.value = v; }
public T get() { return value; }
// Static generic factory method inside a generic class
public static <T> Box<T> of(T v) { return new Box<T>(v); }
}
public static void main(String[] args) {
// Type inferred by diamond and method generic parameter
Box<Integer> bi = Box.of(42);
Box<String> bs = Box.of("hi");
System.out.println(bi.get() + 1);
System.out.println(bs.get().toUpperCase());
}
}
Vérification des méthodes génériques
Vérification rapide : Comment déclarer correctement une méthode générique ?
Récapitulatif
Récapitulatif : Les classes génériques (Pair<T,U>) réduisent la répétition ; les méthodes génériques (signature <T>) fonctionnent indépendamment de la classe. L’inférence de type simplifie les appels.
Questions Fréquemment Posées
La leçon « Méthodes et classes génériques » est-elle gratuite ?
Oui — le texte complet de « Méthodes 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 Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « Méthodes et classes génériques » ?
Définissez des classes génériques avec des paramètres de type et écrivez des méthodes génériques en plaçant <T> avant le type de retour. Découvrez dans quels cas l’inférence de type est utile. Tu pratiques Java 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 Java Academy ?
Aucune expérience préalable n'est requise. Java 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 3 sur 3.
Combien de temps prend la leçon « Méthodes 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 Java Academy ?
Oui. Chaque leçon Java 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
- Les interfaces en pratique
- Bases des génériques (T, inférence)
- Méthodes et classes génériques