Groovy - Generici

I generici consentono ai tipi (classi e interfacce) di essere parametri durante la definizione di classi, interfacce e metodi. In modo molto simile ai parametri formali più familiari utilizzati nelle dichiarazioni di metodo, i parametri di tipo forniscono un modo per riutilizzare lo stesso codice con input diversi. La differenza è che gli input per i parametri formali sono valori, mentre gli input per i parametri di tipo sono tipi.

Generico per le raccolte

Le classi di raccolte come la classe List possono essere generalizzate in modo che nell'applicazione vengano accettate solo raccolte di quel tipo. Di seguito è mostrato un esempio di ArrayList generalizzato. Quello che fa la seguente dichiarazione è che accetta solo voci di elenco che sono di tipo stringa -

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

Nel seguente esempio di codice, stiamo facendo quanto segue:

  • Creazione di una raccolta ArrayList generalizzata che conterrà solo stringhe.
  • Aggiungi 3 stringhe all'elenco.
  • Per ogni elemento della lista, stampa il valore delle stringhe.
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);
      }
   } 
}

L'output del programma di cui sopra sarebbe:

First String 
Second String 
Third String

Classi generalizzate

L'intera classe può anche essere generalizzata. Ciò rende la classe più flessibile nell'accettare qualsiasi tipo e nel lavorare di conseguenza con quei tipi. Diamo un'occhiata a un esempio di come possiamo ottenere questo risultato.

Nel seguente programma, stiamo eseguendo i seguenti passaggi:

  • Stiamo creando una classe chiamata ListType. Notare le parole chiave <T> poste davanti alla definizione della classe. Questo dice al compilatore che questa classe può accettare qualsiasi tipo. Quindi quando dichiariamo un oggetto di questa classe, possiamo specificare un tipo durante la dichiarazione e quel tipo verrebbe sostituito nel segnaposto <T>

  • La classe generica ha semplici metodi getter e setter per lavorare con la variabile membro definita nella classe.

  • Notate nel programma principale che siamo in grado di dichiarare oggetti della classe ListType, ma di diverso tipo. Il primo è del tipo Integer e il secondo è del tipo 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;
   } 
}

L'output del programma di cui sopra sarebbe:

First String 
1