Menu

Tutorial Java Generics con esempi

java generics tutorial with examples

Prova Il Nostro Strumento Per Eliminare I Problemi

I generici Java sono un insieme di funzionalità che consentono di scrivere codice indipendentemente dal tipo di dati. Questo articolo spiega in dettaglio Java Generics con esempi:

I generici sono una delle caratteristiche importanti di Java e sono stati introdotti da Java 5 in poi.

Per definizione, i generici sono un insieme di funzionalità del linguaggio Java che consentono al programmatore di utilizzare tipi e funzioni generici e quindi garantire l'indipendenza dai tipi.

Java Generics

Cosa imparerai:

Come funzionano i generici in Java?

Se hai già lavorato con C ++, Java Generics è lo stesso dei modelli in C ++. Java Generics consente di includere un parametro nella definizione di classe / metodo che avrà il valore di un tipo di dati primitivo.

Per esempio, puoi avere una classe generica 'Array' come segue:

Array di classi {….}

Dov'è il tipo parametrizzato.

Successivamente, puoi creare oggetti per questa classe come segue:

Array int_array = new Array () Array char_array = new Array ();

Quindi, data una classe parametrizzata generica, è possibile creare oggetti della stessa classe con diversi tipi di dati come parametri. Questa è l'essenza principale dell'utilizzo di Java Generics.

Allo stesso modo, è possibile scrivere un metodo generico con un tipo parametrizzato per ordinare un array e quindi creare un'istanza di questo metodo su qualsiasi tipo primitivo.

I generici Java vengono utilizzati principalmente con il framework delle collezioni di Java. Le diverse raccolte come LinkedList, List, Map, HashMap, ecc. Utilizzano Generics per l'implementazione. I generici forniscono l'indipendenza dai tipi poiché il controllo del tipo viene eseguito in fase di compilazione, rendendo così il codice più stabile.

Vediamo ora di più nei dettagli delle classi e dei metodi generici, nonché di altri argomenti correlati.

Classi generiche

Una classe generica è la stessa di una classe normale tranne per il fatto che il nome della classe è seguito da un tipo tra parentesi angolari.

Una definizione generale di una classe generica è la seguente:

class nome_classe
{
variabili di classe;
… ..
metodi di classe;
}

Una volta definita la classe, puoi creare oggetti di qualsiasi tipo di dati desideri come segue:

class_name obj = new class_name ();

Per esempio, per l'oggetto Integer la dichiarazione sarà:

class_name obj = new class_name;

Allo stesso modo, per il tipo di dati String, l'oggetto sarà:

class_name str_Obj = new class_name;

Di seguito è mostrata un'implementazione di esempio per la classe Generic.

class MyGenericClass { T obj; void add(T obj) { this.obj=obj; } T get() { return obj; } } class Main { public static void main(String args()) { MyGenericClass m_int=new MyGenericClass(); m_int.add(2); MyGenericClassmstr=new MyGenericClass(); mstr.add('SoftwaretestingHelp'); System.out.println('Member of MyGenericClass:' + m_int.get()); System.out.println('Member of MyGenericClass:' + mstr.get()); } }

Produzione:

Implementazione per output di classi generiche

domande e risposte dell'intervista di prova agile

Nel programma precedente, una classe MyGenericClass è una classe generica. Ha due metodi, ovvero aggiungi e ottieni. Il metodo add inizializza l'oggetto generico mentre i metodi get restituiscono l'oggetto.

Nella funzione principale, dichiariamo due oggetti di tipo Integer e String ciascuno. Inizializziamo entrambi questi oggetti con i rispettivi valori iniziali utilizzando il metodo add e quindi produciamo il contenuto di questi oggetti utilizzando il metodo get.

Abbiamo presentato l'esempio di classe generico sopra con un parametro di tipo. Ma in realtà, una classe può avere anche più di un parametro di tipo. In questo caso, i parametri di tipo sono separati da una virgola.

L'esempio seguente lo dimostra:

classTest_Generics { T1 obj1; // An object of type T1 T2 obj2; // An object of type T2 // constructor to initialise T1 & T2 objects Test_Generics(T1 obj1, T2 obj2) { this.obj1 = obj1; this.obj2 = obj2; } public void print() { System.out.println('T1 Object:' + obj1); System.out.println('T2 Object:' + obj2); } } class Main { public static void main (String() args) { Test_Genericsobj = newTest_Generics('Java Generics', 1); obj.print(); } }

Produzione:

Tipo di output dei parametri

In questo programma, abbiamo due parametri di tipo, ovvero T1 e T2. Abbiamo funzioni per inizializzare gli oggetti membro e anche per stampare il contenuto. Nella funzione principale, dichiariamo un oggetto con due tipi, ovvero String e Integer. L'output del programma mostra il contenuto dell'oggetto creato.

Proprio come le classi, puoi anche avere interfacce generiche. Impareremo tutto sulle interfacce in un argomento separato.

Metodi generici Java

Proprio come puoi avere classi e interfacce generiche, puoi anche avere metodi generici nel caso in cui non sia necessario che un'intera classe sia generica.

Il seguente programma mostra l'implementazione del metodo generico “printGenericArray”. Notare la chiamata al metodo nella funzione main. Qui effettuiamo due chiamate al metodo Generic, prima con type e poi con type.

public class Main{ public static void printGenericArray(T() items) { for ( T item : items){ System.out.print(item + ' '); } System.out.println(); } public static void main( String args() ) { Integer() int_Array = { 1, 3, 5, 7, 9, 11 }; Character() char_Array = { 'J', 'A', 'V', 'A', 'T','U','T','O','R','I','A', 'L','S' }; System.out.println( 'Integer Array contents:' ); printGenericArray(int_Array ); System.out.println( 'Character Array contents:' ); printGenericArray(char_Array ); } }

Produzione:

Output metodi generici

Parametri di tipo limitati

I parametri di tipo limitato vengono visualizzati quando si desidera limitare i tipi di dati in Generics. Per esempio, se si desidera che una particolare classe o metodo generico o qualsiasi interfaccia che funzioni solo per i tipi di dati numerici, è possibile specificarlo utilizzando la parola chiave 'extends'.

Questo è mostrato di seguito:

List myList = new ArrayList(); List list1 = new ArrayList();

Le due dichiarazioni di cui sopra saranno accettate dal compilatore poiché Long e Integer sono sottoclassi di Number.

La prossima dichiarazione, tuttavia, sarà un problema.

List list = new ArrayList();

Questo darà un errore in fase di compilazione perché String non è un numero. Il simbolo '?' Nell'esempio precedente è noto come carattere jolly e ne parleremo in seguito.

Quindi, in generale, i parametri di tipo limitato vengono utilizzati principalmente quando si desidera limitare i tipi di dati da utilizzare nel codice generics.

Java Generics Wildcard

In Java, un carattere jolly è indicato da un punto interrogativo, '?', Utilizzato per fare riferimento a un tipo sconosciuto. I caratteri jolly vengono utilizzati principalmente con i generici come tipo di parametro.

Quando si utilizzano i caratteri jolly generici, è necessario ricordare un punto che sebbene l'oggetto sia la superclasse di tutte le altre classi, la raccolta di oggetti ( Per esempio, List) non è una superclasse di tutte le altre raccolte.

Oltre ad essere utilizzato come tipo di parametro, è possibile utilizzare un carattere jolly come campo, una variabile locale e come tale. Tuttavia, non è mai possibile utilizzare un carattere jolly come supertipo o come argomento di tipo per richiamare un metodo generico o in caso di creazione di un'istanza di una classe generica.

Ci sono molti esempi di tipi parametrizzati con caratteri jolly (qui almeno un argomento di tipo è un carattere jolly) come mostrato di seguito e i caratteri jolly utilizzati in posizioni diverse verranno interpretati in modo diverso:

  • Collezione Collection indica tutte le istanze dell'interfaccia di raccolta indipendentemente dall'argomento di tipo utilizzato.
  • Elenco : Elenco rappresenta tutti i tipi di elenco in cui il tipo di elemento sarà un numero.
  • Comparatore: Tutte le istanze dell'interfaccia del comparatore per argomenti di tipo che sono Supertipi di stringhe.

Si noti che un tipo con parametri jolly è una regola imposta per riconoscere i tipi validi. Non è un tipo di dati concreto. I caratteri jolly generici possono essere limitati o illimitati.

# 1) Caratteri jolly illimitati

Nei caratteri jolly illimitati, non ci sono restrizioni sulle variabili di tipo ed è indicato come segue:

ArrayList mylist = new ArrayList(); ArrayList my_strList = new ArrayList();

# 2) Caratteri jolly limitati

Abbiamo già discusso i tipi limitati. Questi pongono le restrizioni sul tipo di dati utilizzato per istanziare i parametri del tipo utilizzando le parole chiave: extends o super. Questi caratteri jolly possono essere ulteriormente suddivisi in caratteri jolly delimitati superiori e caratteri jolly delimitati inferiori.

  • Caratteri jolly delimitati superiori

Se si desidera che la propria espressione generica sia valida per tutte le sottoclassi di un determinato tipo, specificare il carattere jolly delimitato superiore con la parola chiave extends.

Per esempio, supponi di richiedere un metodo generico che supporti List, List, ecc., quindi puoi specificare un carattere jolly delimitato superiore come Elenco . Poiché Number è una superclasse, questo metodo generico funzionerà per tutte le sue sottoclassi.

Il seguente programma lo dimostra.

importjava.util.*; public class Main { private static Number summation (List numbers){ double sum = 0.0; for (Number n : numbers) sum += n.doubleValue(); return sum; } public static void main(String() args) { //Number subtype : Integer Listint_list = Arrays.asList(1,3,5,7,9); System.out.println('Sum of the elements in int_list:' + summation(int_list)); //Number subtype : Double List doubles_list = Arrays.asList(1.0,1.5,2.0,2.5,3.0,3.5); System.out.println('Sum of the elements in doubles_list:' + summation(doubles_list)); } }

Produzione:

Output di caratteri jolly delimitati in alto

Qui abbiamo fornito un carattere jolly con limite superiore, List, all'argomento di tipo della funzione 'sommatoria'. Nella funzione principale, definiamo due elenchi, ovvero int_list di tipo Integer e doubles_list di tipo Double. Poiché Integer e Double sono le sottoclassi di Number, la somma delle funzioni funziona perfettamente su entrambi questi elenchi.

  • Caratteri jolly delimitati inferiori

Se si desidera che l'espressione generica accetti tutte le superclassi di un tipo particolare, è possibile specificare un carattere jolly con limite inferiore per l'argomento del tipo.

Di seguito viene fornito un esempio di implementazione per questo:

importjava.util.*; class Main { public static void main(String() args) { //Integer List ListInt_list= Arrays.asList(1,3,5,7); System.out.print('Integer List:'); printforLowerBoundedWildcards(Int_list); //Number list ListNumber_list= Arrays.asList(2,4,6,8); System.out.print('Number List:'); printforLowerBoundedWildcards(Number_list); } public static void printforLowerBoundedWildcards(List list) { System.out.println(list); } }

Produzione:

Uscita di caratteri jolly delimitati inferiori

In questo programma, il carattere jolly del limite inferiore specificato è 'List'. Quindi nella funzione principale, abbiamo un elenco dei tipi e l'elenco. Poiché abbiamo utilizzato il carattere jolly del limite inferiore, la classe Number è una superclasse di Integer è un argomento di tipo valido.

Vantaggi di Java Generics

# 1) Tipo di sicurezza

I generici garantiscono la sicurezza del tipo. Ciò significa che il controllo del tipo viene eseguito in fase di compilazione anziché in fase di esecuzione. Pertanto non vi è alcuna possibilità di ottenere 'ClassCastException' durante il runtime poiché verranno utilizzati i tipi corretti.

importjava.util.*; class Main { public static void main(String() args) { List mylist = new ArrayList(); mylist.add(10); mylist.add('10'); System.out.println(mylist); List list = new ArrayList(); list.add(10); list.add('10');// compile-time error System.out.println(list); } }

Nel programma sopra, abbiamo due elenchi, uno senza farmaci generici e un altro con generici. Nell'elenco non generico, non è presente l'indipendenza dai tipi. Puoi aggiungere un numero intero, una stringa, ecc. Come elemento e viene accettato.

Nell'elenco generico è possibile aggiungere solo un tipo di elemento specificato nell'espressione generica. Se si tenta di aggiungere un elemento di un altro tipo, si verifica un errore in fase di compilazione.

Nel programma precedente l'errore in fase di compilazione lampeggia sulla riga:

list.add('10');

# 2) Riusabilità del codice

Utilizzando Generics, non è necessario scrivere codice separato per ogni tipo di dati. È possibile scrivere una singola classe o metodo ecc. E utilizzarlo per tutti i tipi di dati.

# 3) Non c'è bisogno di Typecasting

Dato che stai usando Generics, il compilatore conosce i tipi usati, quindi non c'è bisogno di typecasting.

Considera il codice seguente:

List mylist = new ArrayList(); mylist.add('Java'); String mystr = (String) list.get(0); //typecasting required

Come puoi vedere quando viene utilizzato un elenco normale, devi digitare l'elemento list nel tipo appropriato nel modo in cui è fatto per il mystr sopra.

Ora scriviamo di nuovo lo stesso codice con un elenco generico.

List list = new ArrayList(); list.add('Java'); String mystr = list.get(0);

Qui abbiamo specificato il tipo di stringa come espressione generica per la dichiarazione della lista. Pertanto, per recuperare singoli elementi di questo elenco, non è necessario eseguire il typecast.

# 4) Implementa algoritmi generici

Puoi implementare molti più algoritmi generici quando usi Generics per codificare.

# 5) Controllo in fase di compilazione

Come già accennato, quando usi Generics nel tuo programma Java, il compilatore controlla i tipi in fase di compilazione, prevenendo così la chiusura anomala del programma in fase di runtime.

Domande frequenti

D # 1) Perché usiamo Generics in Java?

Risposta: I generici garantiscono l'indipendenza dal tipo, ovvero possiamo fornire un parametro di tipo durante la definizione di una classe / interfaccia / metodo ecc. In modo che durante l'istanza effettiva possiamo specificare il tipo effettivo. In questo modo forniamo anche la riusabilità del codice.

come installare subversion in eclipse

D # 2) I generici sono importanti in Java?

Risposta: Sì. In effetti, i generici sono le funzionalità più importanti di Java per garantire la sicurezza dei tipi, ovvero il controllo del tipo in fase di compilazione.

D # 3) Quando Java ha aggiunto i generics?

Risposta: I generics sono stati aggiunti a Java nel 2004 con J2SE 5.0 con l'intenzione di garantire la sicurezza dei tipi in fase di compilazione in Java.

Q # 4) Cos'è un tipo generico?

Risposta: Un tipo generico è una classe, interfaccia o metodo generici forniti con un parametro di tipo. Ciò consente l'indipendenza dai tipi e il riutilizzo del codice.

D # 5) Possiamo usare Generics con Array in Java?

Risposta: No. Java non consente array generici.

Conclusione

Questo conclude il tutorial sui generici di Java che è considerato una delle caratteristiche più importanti nelle recenti versioni di Java. L'utilizzo di Generics nei programmi Java garantisce la sicurezza dei tipi e il riutilizzo del codice. Assicura inoltre il controllo in fase di compilazione in modo che il programma non si interrompa in fase di esecuzione.

I generici Java sono utili principalmente con l'interfaccia delle raccolte Java di cui parleremo in dettaglio in un altro tutorial di questa serie.

Buona lettura!!

Lettura consigliata

^