Java generics

Dans ce tutoriel, nous allons comprendre les generics Java par exemple, comment créer des classes et des méthodes génériques ainsi que leurs avantages.

En Java,GénériqueAide à créer des classes, des interfaces et des méthodes qui peuvent être utilisées avec des objets (données) de différents types. Par conséquent, cela nous permet de réutiliser notre code.

RemarqueSignification :GénériqueLes generics ne s'appliquent pas aux types de base (int, float, char, etc.).

Comment utiliser les generics Java

Pour comprendre comment utiliserGénériqueNous pouvons utiliser les classes de la collection Java ArrayList.

La classe ArrayList est un exemple de classe générique. Nous pouvons utiliser ArrayList pour stocker n'importe quel type de données. Par exemple

import java.util.ArrayList;
class Main {
　　　public static void main(String[] args) {
　　　　　　//Créer une liste d'arrays pour stocker des données Integer
　　　　　　ArrayList<Integer> list1　= new ArrayList<>();
　　　　　　list1.add(4);
　　　　　　list1.add(5);
　　　　　　System.out.println("ArrayList d'Integer : ")　+　list1);
　　　　　　//Créer une liste d'arrays pour stocker des données String
　　　　　　ArrayList<String> list2　= new ArrayList<>();
　　　　　　list2.add("Quatre");
　　　　　　list2.add("Cinq");
　　　　　　System.out.println("ArrayList de String : ")　+　list2);
　　　　　　//Créer une liste d'arrays pour stocker des données Double
　　　　　　ArrayList<Double> list3　= new ArrayList<>();
　　　　　　list3.add(4.5);
　　　　　　list3.add(6.5);
　　　　　　System.out.println("ArrayList of Double: ",　+　list3);
　　　}
}

Résultat de la sortie

ArrayList of Integer: [4,　5]
ArrayList of String: [Four, Five]
ArrayList of Double:4.5,　6.5]

Dans cet exemple, nous avons utilisé la même classe ArrayList pour stocker des éléments de type Integer, String et Double. En raison deGenerics Java, c'est possible.

Voici cette ligne,

ArrayList<Integer> list1　= new ArrayList<>();

Nous avons utilisé Integer entre crochets. Les crochets <> sont appelésParamètres de type.

Le paramètre type est utilisé pour spécifier le type d'objet (données) applicable à la classe générique ou à la méthode.

Création de classe générique

Maintenant que nous connaissons le fonctionnement des generics en Java, voyons comment créer nos propres classes génériques.

Exemple : création de classe générique

class Main {
　　public static void main(String[] args) {
　　　　//Initialiser la classe générique avec des données entières
　　　　GenericsClass<Integer> intObj = new GenericsClass<>(5);
　　　　System.out.println("Classe générique retournant: ",　+　intObj.getData());
　　　　//Initialiser la classe générique avec des données de chaîne
　　　　GenericsClass<String> stringObj = new GenericsClass<>("Java Programming");
　　　　System.out.println("Classe générique retournant: ",　+　stringObj.getData());
　　}
}
class GenericsClass<T> {
　　//Variable de type T
　　private T data;
　　public GenericsClass(T data) {
　　　　this.data = data;
　　}
　　//Méthode retournant une variable de type T
　　public T getData() {
　　　　return this.data;
　　}
}

Résultat de la sortie

Classe générique retournant:　5
Classe générique retournant: Java Programing

Dans cet exemple, nous avons créé une classe générique nommée GenericsClass. Cette classe peut être utilisée pour traiter n'importe quel type de données.

class GenericsClass<T> {...}

Ici, T représenteParamètres de typeDans la classe Main, nous avons créé des objets de la classe GenericsClass nommés intObj et stringObj.

• Lors de la création de intObj, le paramètre de type T est remplacé par Integer. Cela signifie que intObj utilise GenericsClass pour traiter les données entières.

• Lors de la création de stringObj, le paramètre de type T est remplacé par String. Cela signifie que stringObj utilise GenericsClass pour traiter les données de chaîne.

Création de méthode générique

Comme pour une classe générique, nous pouvons également créer nos propres méthodes génériques en Java.

Exemple : création de méthode générique

class Main {
　　public static void main(String[] args) {
　　　　//Initialisation de la classe avec des données Integer
　　　　DemoClass demo = new DemoClass();
　　　　demo.<String>genericMethod("Java Programming");
　　}
}
class DemoClass {
　　//Méthode générique
　　public <T> void genericsMethod(T data) {
　　　　System.out.println("C'est une méthode générique.");
　　　　System.out.println("Les données passées à la méthode sont "　+　data);
　　}
}

Résultat de la sortie

C'est une méthode générique.
Les données passées à la méthode sont: Java Programming

Dans l'exemple suivant, nous avons créé une méthode générique nommée genericsMethod à l'intérieur d'une classe normale (DemoClass).

public <T> void genericMethod(T data) {...

Ici, le paramètre de type <T> est inséré après le modificateur (public) et avant le type de retour (void).

Nous pouvons appeler une méthode générique en plaçant le type réel <String> avant les parenthèses du nom de la méthode.

demo.<String>genericMethod("Java Programming");

Attention：Dans la plupart des cas, nous pouvons omettre le paramètre type lors de l'appel d'une méthode générique. C'est parce que le compilateur peut utiliser la valeur passée au méthode pour correspondre au paramètre de type. Par exemple,

demo.genericsMethod("Java Programming");

de type borné

En règle générale,Paramètre de typepeut accepter n'importe quel type de données (à l'exception des types de base). Mais si nous ne voulons utiliser les generics que pour certains types spécifiques (par exemple, accepter des types de données numériques), nous pouvons utiliser des types bornés.

Nous utilisons la clause extends. Par exemple,

<T extends A>

Ce qui signifie que T ne peut accepter que des types de données de sous-type de A.

Exemple : types bornés

class GenericsClass<T extends Number> {
　　public void display() {}}
　　　　System.out.println("Ceci est une classe générique bornée.");
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　//Créer un objet GenericsClass
　　　　GenericsClass<String> obj = new GenericsClass<>();
　　}
}

Dans l'exemple ci-dessus, nous avons créé unede type bornéde la classe générique. Ici, notez l'expression

<T extends Number>

Cela signifie que T ne peut utiliser que les sous-types de données de Number (Integer, Double, etc.).

Mais, nous avons déjà créé un objet de classe générique avec String. C'est pourquoi, lorsque nous exécutons le programme, nous obtenons l'erreur suivante.

GenericsClass<String> obj = new GenericsClass<>();
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　^
　　　　raison: l'inference variable T a des bornes incompatibles
　　　　　　contraintes d'égalité: String
　　　　　　bornes inférieures: Number
　　où T est un type-variable:
　　　　T extends Number déclaré dans la classe GenericsClass

Avantages des generics en Java

1.Réutilisabilité du code

GénériqueNous permet de rédiger du code applicable à différents types de données. Par exemple,

public <T> void genericsMethod(T data) {...}

Ici, nous créons une méthode générique. Cette méthode peut être utilisée pour effectuer des opérations sur des données entières, des données de chaîne, etc.

2.Vérification de type à la compilation

GénériqueParamètre de typeFournir des informations sur le type de données utilisé dans le code générique.

Par conséquent, toute erreur peut être détectée au moment de la compilation, ce qui est plus facile à corriger que les erreurs au moment de l'exécution. Par exemple,

//Sans utiliser de générique
NormalClass list = new NormalClass();
//Appel de la méthode de NormalClass
list.display("String");

Dans le code ci-dessus, nous avons une classe ordinaire. Nous appelons la méthode display() de cette classe en passant des données de chaîne.

Ici, le compilateur ne sait pas si la valeur passée en paramètre est correcte. Mais regardons ce qui se passe si nous utilisons une classe générique.

//Use generics
GenericsClass<Integer> list = new GenericsClass<>();
//Call the method of GenericsClass
list2.display("String");
In the above code, we have a generic class. Here, the type parameter indicates that this class is processing Integer data.
Therefore, when string data is passed as a parameter, the compiler will generate an error.

3. generics are used with collections

The collection framework uses the generic concept in Java. For example,

//　Create a string type ArrayList
ArrayList<String> list1　= new ArrayList<>();
//　Create an integer type ArrayList
ArrayList<Integer> list2　= new ArrayList<>();

In the above example, we used the same ArrayList class to handle different types of data.

Similar to ArrayList, other collections (LinkedList, Queue, Maps, etc.) are also Java generics.