Java - Génériques
Ce serait bien si nous pouvions écrire une seule méthode de tri qui pourrait trier les éléments dans un tableau Integer, un tableau String ou un tableau de n'importe quel type prenant en charge le tri.
Java Générique les méthodes et les classes génériques permettent aux programmeurs de spécifier, avec une seule déclaration de méthode, un ensemble de méthodes liées, ou avec une seule déclaration de classe, un ensemble de types liés, respectivement.
Les génériques fournissent également une sécurité de type au moment de la compilation qui permet aux programmeurs d'intercepter les types non valides au moment de la compilation.
En utilisant le concept Java Generic, nous pourrions écrire une méthode générique pour trier un tableau d'objets, puis invoquer la méthode générique avec des tableaux Integer, Double arrays, String arrays, etc., pour trier les éléments du tableau.
Méthodes génériques
Vous pouvez écrire une seule déclaration de méthode générique qui peut être appelée avec des arguments de différents types. En fonction des types des arguments passés à la méthode générique, le compilateur gère chaque appel de méthode de manière appropriée. Voici les règles pour définir les méthodes génériques −
-
Toutes les déclarations de méthode génériques ont une section de paramètre de type délimitée par des crochets angulaires (
) qui précède le type de retour de la méthode ( dans l'exemple suivant). -
Chaque section de paramètre de type contient un ou plusieurs paramètres de type séparés par des virgules. Un paramètre de type, également appelé variable de type, est un identifiant qui spécifie un nom de type générique.
-
Les paramètres de type peuvent être utilisés pour déclarer le type de retour et agir comme des espaces réservés pour les types des arguments passés à la méthode générique, appelés arguments de type réels.
-
Le corps d'une méthode générique est déclaré comme celui de toute autre méthode. Notez que les paramètres de type ne peuvent représenter que des types de référence, pas des types primitifs (comme int, double et char).
Exemple
L'exemple suivant illustre comment nous pouvons imprimer un tableau de type différent en utilisant une seule méthode générique −
Démo en direct
public class GenericMethodTest {
// generic method printArray
public static < E > void printArray( E[] inputArray ) {
// Display array elements
for(E element : inputArray) {
System.out.printf("%s ", element);
}
System.out.println();
}
public static void main(String args[]) {
// Create arrays of Integer, Double and Character
Integer[] intArray = { 1, 2, 3, 4, 5 };
Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
System.out.println("Array integerArray contains:");
printArray(intArray); // pass an Integer array
System.out.println("\nArray doubleArray contains:");
printArray(doubleArray); // pass a Double array
System.out.println("\nArray characterArray contains:");
printArray(charArray); // pass a Character array
}
}
Cela produira le résultat suivant −
Sortie
Array integerArray contains: 1 2 3 4 5 Array doubleArray contains: 1.1 2.2 3.3 4.4 Array characterArray contains: H E L L O
Paramètres de type borné
Il peut arriver que vous souhaitiez restreindre les types de types autorisés à être passés à un paramètre de type. Par exemple, une méthode qui opère sur des nombres peut ne vouloir accepter que des instances de Number ou de ses sous-classes. C'est à cela que servent les paramètres de type borné.
Pour déclarer un paramètre de type délimité, indiquez le nom du paramètre de type, suivi du mot clé extend, suivi de sa limite supérieure.
Exemple
L'exemple suivant illustre comment les extensions sont utilisées dans un sens général pour signifier soit "s'étend" (comme dans les classes) soit "implémente" (comme dans les interfaces). Cet exemple est la méthode générique pour renvoyer le plus grand des trois objets comparables −
Démo en direct
public class MaximumTest {
// determines the largest of three Comparable objects
public static <T extends Comparable<T>> T maximum(T x, T y, T z) {
T max = x; // assume x is initially the largest
if(y.compareTo(max) > 0) {
max = y; // y is the largest so far
}
if(z.compareTo(max) > 0) {
max = z; // z is the largest now
}
return max; // returns the largest object
}
public static void main(String args[]) {
System.out.printf("Max of %d, %d and %d is %d\n\n",
3, 4, 5, maximum( 3, 4, 5 ));
System.out.printf("Max of %.1f,%.1f and %.1f is %.1f\n\n",
6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ));
System.out.printf("Max of %s, %s and %s is %s\n","pear",
"apple", "orange", maximum("pear", "apple", "orange"));
}
}
Cela produira le résultat suivant −
Sortie
Max of 3, 4 and 5 is 5 Max of 6.6,8.8 and 7.7 is 8.8 Max of pear, apple and orange is pear
Classes génériques
Une déclaration de classe générique ressemble à une déclaration de classe non générique, sauf que le nom de la classe est suivi d'une section de paramètre de type.
Comme pour les méthodes génériques, la section des paramètres de type d'une classe générique peut avoir un ou plusieurs paramètres de type séparés par des virgules. Ces classes sont appelées classes paramétrées ou types paramétrés car elles acceptent un ou plusieurs paramètres.
Exemple
L'exemple suivant illustre comment nous pouvons définir une classe générique −
Démo en direct
public class Box<T> {
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
public static void main(String[] args) {
Box<Integer> integerBox = new Box<Integer>();
Box<String> stringBox = new Box<String>();
integerBox.add(new Integer(10));
stringBox.add(new String("Hello World"));
System.out.printf("Integer Value :%d\n\n", integerBox.get());
System.out.printf("String Value :%s\n", stringBox.get());
}
}
Cela produira le résultat suivant −
Sortie
Integer Value :10 String Value :Hello World
Java