Groovy - Génériques

Les génériques permettent aux types (classes et interfaces) d'être des paramètres lors de la définition des classes, des interfaces et des méthodes. Tout comme les paramètres formels plus familiers utilisés dans les déclarations de méthode, les paramètres de type vous permettent de réutiliser le même code avec différentes entrées. La différence est que les entrées des paramètres formels sont des valeurs, tandis que les entrées des paramètres de type sont des types.

Générique pour les collections

Les classes de collections telles que la classe List peuvent être généralisées afin que seules les collections de ce type soient acceptées dans l'application. Un exemple de ArrayList généralisé est présenté ci-dessous. L'instruction suivante n'accepte que les éléments de liste qui sont de type chaîne -

List<String> list = new ArrayList<String>();

Dans l'exemple de code suivant, nous procédons comme suit -

  • Création d'une collection ArrayList généralisée qui ne contiendra que des chaînes.
  • Ajoutez 3 chaînes à la liste.
  • Pour chaque élément de la liste, impression de la valeur des chaînes.
class Example {
   static void main(String[] args) {
      // Creating a generic List collection
      List<String> list = new ArrayList<String>();
      list.add("First String");
      list.add("Second String");
      list.add("Third String");
		
      for(String str : list) {
         println(str);
      }
   } 
}

La sortie du programme ci-dessus serait -

First String 
Second String 
Third String

Classes généralisées

La classe entière peut également être généralisée. Cela rend la classe plus flexible pour accepter tous les types et travailler en conséquence avec ces types. Regardons un exemple de la façon dont nous pouvons y parvenir.

Dans le programme suivant, nous effectuons les étapes suivantes -

  • Nous créons une classe appelée ListType. Notez les mots-clés <T> placés devant la définition de classe. Cela indique au compilateur que cette classe peut accepter n'importe quel type. Ainsi, lorsque nous déclarons un objet de cette classe, nous pouvons spécifier un type lors de la déclaration et ce type serait remplacé dans l'espace réservé <T>

  • La classe générique a de simples méthodes getter et setter pour travailler avec la variable membre définie dans la classe.

  • Dans le programme principal, notez que nous sommes en mesure de déclarer des objets de la classe ListType, mais de types différents. Le premier est de type Integer et le second est de type String.

class Example {
   static void main(String[] args) {
      // Creating a generic List collection 
      ListType<String> lststr = new ListType<>();
      lststr.set("First String");
      println(lststr.get()); 
		
      ListType<Integer> lstint = new ListType<>();
      lstint.set(1);
      println(lstint.get());
   }
} 

public class ListType<T> {
   private T localt;
	
   public T get() {
      return this.localt;
   }
	
   public void set(T plocal) {
      this.localt = plocal;
   } 
}

La sortie du programme ci-dessus serait -

First String 
1