Introduction
À partir de JSE 5.0, des génériques ont été ajoutés à l'arsenal du langage Java.Que sont les génériques en Java ?
Les génériques sont le mécanisme spécial de Java pour implémenter la programmation générique - un moyen de décrire des données et des algorithmes qui vous permet de travailler avec différents types de données sans modifier la description des algorithmes. Le site Web d'Oracle propose un didacticiel séparé dédié aux génériques : " Lesson ". Pour comprendre les génériques, vous devez d'abord comprendre pourquoi ils sont nécessaires et ce qu'ils donnent. La section « Pourquoi utiliser des génériques ?
Préparons-nous à quelques tests dans notre bien-aimé compilateur Java en ligne Tutorialspoint . Supposons que vous ayez le code suivant :
import java.util.*;
public class HelloWorld {
public static void main(String []args) {
List list = new ArrayList();
list.add("Hello");
String text = list.get(0) + ", world!";
System.out.print(text);
}
}error: incompatible types: Object cannot be converted to Stringimport java.util.*;
public class HelloWorld {
public static void main(String []args) {
List list = new ArrayList();
list.add("Hello!");
list.add(123);
for (Object str : list) {
System.out.println("-" + (String)str);
}
}
}java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.Stringimport java.util.*;
public class HelloWorld {
public static void main(String []args) {
List<String> list = new ArrayList<>();
list.add("Hello!");
list.add(123);
for (Object str : list) {
System.out.println("-" + str);
}
}
}
Après compilation, tous les génériques sont effacés. C'est ce qu'on appelle " l'effacement de type". L'effacement de type et les génériques sont conçus pour être rétrocompatibles avec les anciennes versions du JDK tout en permettant simultanément au compilateur d'aider avec les définitions de type dans les nouvelles versions de Java.
Types bruts
En parlant de génériques, nous avons toujours deux catégories : les types paramétrés et les types bruts. Les types bruts sont des types qui omettent la « clarification de type » entre crochets :
les types paramétrés, quant à eux, incluent une « clarification » : 
comme vous pouvez le voir, nous avons utilisé une construction inhabituelle, marquée par une flèche dans la capture d'écran. C'est une syntaxe spéciale qui a été ajoutée à Java SE 7. C'est ce qu'on appelle le « diamant ». Pourquoi? Les chevrons forment un losange : <> . Il faut aussi savoir que la syntaxe en losange est associée à la notion d'« inférence de type ». Après tout, le compilateur, voyant <>à droite, regarde le côté gauche de l'opérateur d'affectation, où il trouve le type de la variable dont la valeur est affectée. Sur la base de ce qu'il trouve dans cette partie, il comprend le type de la valeur à droite. En fait, si un type générique est donné à gauche, mais pas à droite, le compilateur peut déduire le type :
import java.util.*;
public class HelloWorld {
public static void main(String []args) {
List<String> list = new ArrayList();
list.add("Hello, World");
String data = list.get(0);
System.out.println(data);
}
}Note: HelloWorld.java uses unchecked or unsafe operationsimport java.util.*;
public class HelloWorld {
public static void main(String []args) {
List<String> list = Arrays.asList("Hello", "World");
List<Integer> data = new ArrayList(list);
Integer intNumber = data.get(0);
System.out.println(data);
}
}Méthodes génériques Java
Les génériques vous permettent de créer des méthodes dont les types de paramètres et le type de retour sont paramétrés. Une section distincte est consacrée à cette fonctionnalité dans le didacticiel Oracle : " Méthodes génériques ". Il est important de se souvenir de la syntaxe enseignée dans ce tutoriel :- il inclut une liste de paramètres de type entre crochets ;
- la liste des paramètres de type précède le type de retour de la méthode.
import java.util.*;
public class HelloWorld {
public static class Util {
public static <T> T getValue(Object obj, Class<T> clazz) {
return (T) obj;
}
public static <T> T getValue(Object obj) {
return (T) obj;
}
}
public static void main(String []args) {
List list = Arrays.asList("Author", "Book");
for (Object element : list) {
String data = Util.getValue(element, String.class);
System.out.println(data);
System.out.println(Util.<String>getValue(element));
}
}
}import java.util.*;
public class HelloWorld {
public static class Util {
public static <T> T getValue(Object obj) {
return (T) obj;
}
}
public static void main(String []args) {
List list = Arrays.asList(2, 3);
for (Object element : list) {
System.out.println(Util.<Integer>getValue(element) + 1);
}
}
}System.out.println(Util.getValue(element) + 1);bad operand types for binary operator '+', first type: Object, second type: int.Classes génériques
Il n'y a pas que les méthodes qui peuvent être paramétrées. Les cours peuvent aussi. La section "Generic Types" du tutoriel d'Oracle y est consacrée. Prenons un exemple :public static class SomeType<T> {
public <E> void test(Collection<E> collection) {
for (E element : collection) {
System.out.println(element);
}
}
public void test(List<Integer> collection) {
for (Integer element : collection) {
System.out.println(element);
}
}
}public static void main(String []args) {
SomeType<String> st = new SomeType<>();
List<String> list = Arrays.asList("test");
st.test(list);
}SomeType st = new SomeType();
List<String> list = Arrays.asList("test");
st.test(list);java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.IntegerRestrictions
Nous pouvons restreindre les types spécifiés dans les méthodes génériques et n classes. Par exemple, supposons que nous voulions qu'un conteneur n'accepte qu'un nombre comme argument de type. Cette fonctionnalité est décrite dans la section Bounded Type Parameters du tutoriel d'Oracle. Regardons un exemple :import java.util.*;
public class HelloWorld {
public static class NumberContainer<T extends Number> {
private T number;
public NumberContainer(T number) { this.number = number; }
public void print() {
System.out.println(number);
}
}
public static void main(String []args) {
NumberContainer number1 = new NumberContainer(2L);
NumberContainer number2 = new NumberContainer(1);
NumberContainer number3 = new NumberContainer("f");
}
}
public static class NumberContainer<T extends Number & Comparable> {- Caractères génériques à limite supérieure — < ? étend Nombre >
- Caractères génériques illimités — < ? >
- Caractères génériques délimités inférieurs — < ? super entier >
- Utilisez un caractère générique d'extension lorsque vous n'obtenez que des valeurs d'une structure.
- Utilisez un super caractère générique lorsque vous mettez uniquement des valeurs dans une structure.
- Et n'utilisez pas de caractère générique lorsque vous voulez tous les deux obtenir et mettre depuis/vers une structure.
Et voici un petit exemple de ce qui ne fonctionnera PAS :
public static class TestClass {
public static void print(List<? extends String> list) {
list.add("Hello, World!");
System.out.println(list.get(0));
}
}
public static void main(String []args) {
List<String> list = new ArrayList<>();
TestClass.print(list);
}Héritage
Les génériques ont une autre caractéristique intéressante : l'héritage. Le fonctionnement de l'héritage pour les génériques est décrit sous " Génériques, héritage et sous-types " dans le didacticiel d'Oracle. L'important est de se rappeler et de reconnaître ce qui suit. Nous ne pouvons pas faire ceci :List<CharSequence> list1 = new ArrayList<String>();
Et voici un autre bon exemple qui échouera avec une erreur :
List<String> list1 = new ArrayList<>();
List<Object> list2 = list1;Conclusion
Nous nous sommes donc rafraîchi la mémoire concernant les génériques. Si vous tirez rarement pleinement parti de leurs capacités, certains détails deviennent flous. J'espère que cette courte critique vous a aidé à vous rafraîchir la mémoire. Pour des résultats encore meilleurs, je vous recommande fortement de vous familiariser avec le matériel suivant :|
Plus de lecture : |
|---|