In questo tutorial, impareremo a conoscere Java Generics, come creare classi e metodi generici e i suoi vantaggi con l'aiuto di esempi.
Java Generics ci consente di creare un'unica classe, interfaccia e metodo che può essere utilizzato con diversi tipi di dati (oggetti).
Questo ci aiuta a riutilizzare il nostro codice.
Nota : Generics non funziona con i tipi primitivi ( int, float, char, ecc).
Java Generics Class
Possiamo creare una classe che può essere utilizzata con qualsiasi tipo di dati. Una tale classe è conosciuta come Generics Class.
Ecco come possiamo creare una classe di generici in Java:
Esempio: creare una lezione sui generici
class Main ( public static void main(String() args) ( // initialize generic class // with Integer data GenericsClass intObj = new GenericsClass(5); System.out.println("Generic Class returns: " + intObj.getData()); // initialize generic class // with String data GenericsClass stringObj = new GenericsClass("Java Programming"); System.out.println("Generic Class returns: " + stringObj.getData()); ) ) // create a generics class class GenericsClass ( // 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; ) )
Produzione
Restituisce la classe generica: 5 Restituisce la classe generica: Programmazione Java
Nell'esempio precedente, abbiamo creato una classe generica denominata GenericsClass. Questa classe può essere utilizzata per lavorare con qualsiasi tipo di dati.
class GenericsClass (… )
Qui, la T usata all'interno della parentesi angolare indica il parametro del tipo . All'interno della Mainclasse, abbiamo creato due oggetti di GenericsClass
- intObj - Qui, il parametro di tipo T è sostituito da
Integer. Ora, GenericsClass funziona con dati interi. - stringObj - Qui, il parametro di tipo T è sostituito da
String. Ora, la GenericsClass funziona con dati di stringa.
Metodo Java Generics
Simile alla classe generics, possiamo anche creare un metodo che può essere utilizzato con qualsiasi tipo di dati. Tale classe è nota come metodo Generics.
Ecco come possiamo creare una classe di generici in Java:
Esempio: creare un metodo Generics
class Main ( public static void main(String() args) ( // initialize the class with Integer data DemoClass demo = new DemoClass(); // generics method working with String demo.genericsMethod("Java Programming"); // generics method working with integer demo.genericsMethod(25); ) ) class DemoClass ( // creae a generics method public void genericsMethod(T data) ( System.out.println("Generics Method:"); System.out.println("Data Passed: " + data); ) )
Produzione
Metodo Generics: Dati passati: Java Programming Metodo Generics: Dati passati: 25
Nell'esempio precedente, abbiamo creato un metodo generico denominato genericsMethod.
public void genericMethod(T data) (… )
Qui, il parametro type viene inserito dopo il modificatore publice prima del tipo restituito void.
Possiamo chiamare il metodo generics inserendo il tipo effettivo e all'interno della parentesi prima del nome del metodo.
demo.genericMethod("Java Programming"); demo.genericMethod(25);
Nota : possiamo chiamare il metodo generics senza includere il parametro type. Per esempio,
demo.genericsMethod("Java Programming");
In questo caso, il compilatore può abbinare il parametro di tipo in base al valore passato al metodo.
Tipi limitati
In generale, il parametro type può accettare qualsiasi tipo di dati (eccetto i tipi primitivi).
Tuttavia, se si desidera utilizzare i generici solo per alcuni tipi specifici (come accettare dati di tipi numerici), è possibile utilizzare i tipi limitati.
Nel caso dei tipi legati, usiamo la extendsparola chiave. Per esempio,
Ciò significa che T può accettare solo dati che sono sottotipi di A.
Esempio: tipi limitati
class GenericsClass ( 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 obj = new GenericsClass(); ) )
Nell'esempio precedente, abbiamo creato una classe denominata GenericsClass. Notare l'espressione, notare l'espressione
Qui, GenericsClass viene creato con il tipo limitato. Questo significa GenericsClass può solo lavorare con i tipi di dati che sono figli di Number( Integer, Double, e così via).
Tuttavia, abbiamo creato un oggetto della classe dei generici con String. In questo caso, otterremo il seguente errore.
GenericsClass obj = new GenericsClass (); motivo: la variabile di inferenza T ha limiti incompatibili vincoli di uguaglianza: String limiti inferiori: Number dove T è una variabile di tipo: T estende Numero dichiarato nella classe GenericsClass
Vantaggi di Java Generics
1. Riusabilità del codice
Con l'aiuto dei generici in Java, possiamo scrivere codice che funzionerà con diversi tipi di dati. Per esempio,
public void genericsMethod(T data) (… )
Qui abbiamo creato un metodo dei generici. Questo stesso metodo può essere utilizzato per eseguire operazioni su dati interi, dati stringa e così via.
2. Controllo del tipo in fase di compilazione
Il parametro type di generics fornisce informazioni sul tipo di dati utilizzati nel codice generics. Per esempio,
// using Generics GenericsClass list = new GenericsClass();
Qui sappiamo che GenericsClass sta lavorando Integersolo con i dati.
Ora, se proviamo a passare dati diversi da Integer a questa classe, il programma genererà un errore in fase di compilazione.
3. Utilizzato con le collezioni
Il framework delle collezioni utilizza il concetto di generici in Java. Per esempio,
// creating a string type ArrayList ArrayList list1 = new ArrayList(); // creating a integer type ArrayList ArrayList list2 = new ArrayList();
Nell'esempio precedente, abbiamo utilizzato la stessa classe ArrayList per lavorare con diversi tipi di dati.
Simile a ArrayList, altre collezioni ( LinkedList, Queue, Mapse così via) sono anche generici in Java.
