Génériques Java

Dans ce didacticiel, nous allons découvrir Java Generics, comment créer des classes et des méthodes génériques et ses avantages à l'aide d'exemples.

Les génériques Java nous permettent de créer une classe, une interface et une méthode uniques pouvant être utilisées avec différents types de données (objets).

Cela nous aide à réutiliser notre code.

Remarque :Génériques ne fonctionne pas avec les types primitifs (int , float , char , etc.).

Classe des génériques Java

Nous pouvons créer une classe qui peut être utilisée avec n'importe quel type de données. Une telle classe est connue sous le nom de classe générique.

Voici comment créer une classe de génériques en Java :

Exemple :créer une classe de génériques

class Main {
  public static void main(String[] args) {

    // initialize generic class
    // with Integer data
    GenericsClass<Integer> intObj = new GenericsClass<>(5);
    System.out.println("Generic Class returns: " + intObj.getData());

    // initialize generic class
    // with String data
    GenericsClass<String> stringObj = new GenericsClass<>("Java Programming");
    System.out.println("Generic Class returns: " + stringObj.getData());
  }
}

// create a generics class
class GenericsClass<T> {

  // variable of T type
  private T data;

  public GenericsClass(T data) {
    this.data = data;
  }

  // method that return T type variable
  public T getData() {
    return this.data;
  }
}

Sortie

Generic Class returns: 5
Generic Class returns: Java Programming

Dans l'exemple ci-dessus, nous avons créé une classe générique nommée GenericsClass . Cette classe peut être utilisée pour travailler avec n'importe quel type de données.

class GenericsClass<T> {...}

Ici, T utilisé à l'intérieur de l'équerre <> indique le paramètre de type . À l'intérieur du Main class, nous avons créé deux objets de GenericsClass

intObj - Ici, le paramètre de type T est remplacé par Integer . Maintenant, la GenericsClass fonctionne avec des données entières.
chaîneObj - Ici, le paramètre de type T est remplacé par String . Maintenant, la GenericsClass fonctionne avec des données de chaîne.

Méthode des génériques Java

Semblable à la classe des génériques, nous pouvons également créer une méthode qui peut être utilisée avec n'importe quel type de données. Une telle classe est connue sous le nom de méthode générique.

Voici comment créer une classe de génériques en Java :

Exemple :créer une méthode générique

class Main {
  public static void main(String[] args) {

    // initialize the class with Integer data
    DemoClass demo = new DemoClass();

    // generics method working with String
    demo.<String>genericsMethod("Java Programming");

    // generics method working with integer
    demo.<Integer>genericsMethod(25);
  }
}

class DemoClass {

  // creae a generics method
  public <T> void genericsMethod(T data) {
    System.out.println("Generics Method:");
    System.out.println("Data Passed: " + data);
  }
}

Sortie

Generics Method:
Data Passed: Java Programming
Generics Method:
Data Passed: 25

Dans l'exemple ci-dessus, nous avons créé une méthode générique nommée genericsMethod .

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 la méthode des génériques en plaçant le type réel <String> et <Integer> à l'intérieur du crochet avant le nom de la méthode.

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

demo.<Integer>genericMethod(25);

Remarque :Nous pouvons appeler la méthode des génériques sans inclure le paramètre de type. Par exemple,

demo.genericsMethod("Java Programming");

Dans ce cas, le compilateur peut faire correspondre le paramètre de type en fonction de la valeur transmise à la méthode.

Types limités

En général, le paramètre de type peut accepter tous les types de données (à l'exception des types primitifs).

Toutefois, si nous souhaitons utiliser des génériques pour certains types spécifiques (tels que l'acceptation de données de types numériques) uniquement, nous pouvons utiliser des types limités.

Dans le cas des types liés, nous utilisons le extends mot-clé. Par exemple,

<T extends A>

Cela signifie T ne peut accepter que les données qui sont des sous-types de A .

Exemple :Types délimités

class GenericsClass <T extends Number> {

  public void display() {
    System.out.println("This is a bounded type generics class.");
  }
}

class Main {
  public static void main(String[] args) {

    // create an object of GenericsClass
    GenericsClass<String> obj = new GenericsClass<>();
  }
}

Dans l'exemple ci-dessus, nous avons créé une classe nommée GenericsClass. Remarquez l'expression, remarquez l'expression

<T extends Number>

Ici, GenericsClass est créé avec un type borné. Cela signifie GenericsClass ne peut fonctionner qu'avec des types de données qui sont des enfants de Number (Integer , Double , etc.).

Cependant, nous avons créé un objet de la classe génériques avec String . Dans ce cas, nous obtiendrons l'erreur suivante.

GenericsClass<String> obj = new GenericsClass<>();
                                                 ^
    reason: inference variable T has incompatible bounds
      equality constraints: String
      lower bounds: Number
  where T is a type-variable:
    T extends Number declared in class GenericsClass

Avantages des génériques Java

1. Réutilisabilité du code

Avec l'aide de génériques en Java, nous pouvons écrire du code qui fonctionnera avec différents types de données. Par exemple,

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

Ici, nous avons créé une méthode générique. Cette même 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

Le paramètre de type des génériques fournit des informations sur le type de données utilisées dans le code des génériques. Par exemple,

// using Generics
GenericsClass<Integer> list = new GenericsClass<>();

Ici, nous savons que GenericsClass fonctionne avec Integer données uniquement.

Maintenant, si nous essayons de transmettre des données autres que Integer à cette classe, le programme générera une erreur au moment de la compilation.

3. Utilisé avec les collections

Le framework de collections utilise le concept de génériques en Java. Par exemple,

// creating a string type ArrayList
ArrayList<String> list1 = new ArrayList<>();

// creating a integer type ArrayList
ArrayList<Integer> list2 = new ArrayList<>();

Dans l'exemple ci-dessus, nous avons utilisé la même classe ArrayList pour travailler avec différents types de données.

Similaire à ArrayList , autres collections (LinkedList , Queue , Maps , etc.) sont également génériques en Java.

Expressions Java Lambda Classe de fichier Java

Java