Non aver bisogno di typecast è uno dei maggiori vantaggi dei generici Java , poiché eseguirà il controllo del tipo in fase di compilazione. Ciò ridurrà la possibilità di messaggi di posta ClassCastExceptionelettronica che possono essere lanciati in fase di esecuzione e può portare a un codice più robusto.
Ma sospetto che tu ne sia pienamente consapevole.
Ogni volta che guardo i Generics mi viene il mal di testa. Trovo che la parte migliore di Java sia la semplicità e la sintassi minima e i generici non sono semplici e aggiungono una quantità significativa di nuova sintassi.
In un primo momento, non ho visto nemmeno il beneficio dei generici. Ho iniziato ad imparare Java dalla sintassi 1.4 (anche se Java 5 era fuori in quel momento) e quando ho incontrato i generici, ho sentito che era più codice da scrivere e non ho davvero capito i vantaggi.
Gli IDE moderni semplificano la scrittura di codice con i generici.
La maggior parte degli IDE moderni e decenti sono abbastanza intelligenti da aiutare a scrivere codice con i generici, specialmente con il completamento del codice.
Ecco un esempio di creazione Map<String, Integer>di un file HashMap. Il codice che dovrei digitare è:
Map<String, Integer> m = new HashMap<String, Integer>();
E in effetti, è molto da scrivere solo per crearne uno nuovo HashMap. Tuttavia, in realtà, ho dovuto digitare solo così tanto prima che Eclipse sapesse di cosa avevo bisogno:
Map<String, Integer> m = new Ha Ctrl+Space
È vero, avevo bisogno di selezionare HashMapda un elenco di candidati, ma fondamentalmente l'IDE sapeva cosa aggiungere, compresi i tipi generici. Con gli strumenti giusti, usare i generici non è poi così male.
Inoltre, poiché i tipi sono noti, quando si recuperano elementi dalla raccolta generica, l'IDE si comporterà come se quell'oggetto fosse già un oggetto del suo tipo dichiarato: non è necessario eseguire il casting per l'IDE per sapere quale sia il tipo di oggetto è.
Un vantaggio chiave dei generici deriva dal modo in cui funziona bene con le nuove funzionalità di Java 5. Ecco un esempio di come inserire numeri interi in a Sete calcolarne il totale:
Set<Integer> set = new HashSet<Integer>();
set.add(10);
set.add(42);
int total = 0;
for (int i : set) {
total += i;
}
In quel pezzo di codice, ci sono tre nuove funzionalità di Java 5 presenti:
Innanzitutto, i generici e l'autoboxing delle primitive consentono le seguenti righe:
set.add(10);
set.add(42);
L'intero 10viene inserito automaticamente in un Integercon il valore di 10. (E lo stesso per 42). Quindi quello Integerviene gettato in quello Setche è noto per contenere Integers. Il tentativo di lanciare un Stringcauserebbe un errore di compilazione.
Successivamente, for for-each loop prende tutti e tre quelli:
for (int i : set) {
total += i;
}
In primo luogo, i Setcontenitori Integervengono usati in un ciclo for-each. Ogni elemento è dichiarato come an inte ciò è consentito in quanto Integerviene ripristinato alla primitiva int. E il fatto che si verifichi questo unboxing è noto perché i generici sono stati utilizzati per specificare che erano Integertenuti in Set.
I generici possono essere il collante che riunisce le nuove funzionalità introdotte in Java 5 e rende la codifica più semplice e sicura. E la maggior parte delle volte gli IDE sono abbastanza intelligenti da aiutarti con buoni suggerimenti, quindi in generale, non sarà molto più necessario digitare.
E francamente, come si può vedere Setdall'esempio, ritengo che l'utilizzo delle funzionalità di Java 5 possa rendere il codice più conciso e robusto.
Modifica: un esempio senza generici
Quanto segue è un'illustrazione dell'esempio precedente Setsenza l'uso di generici. È possibile, ma non è esattamente piacevole:
Set set = new HashSet();
set.add(10);
set.add(42);
int total = 0;
for (Object o : set) {
total += (Integer)o;
}
(Nota: il codice sopra genererà un avviso di conversione non controllato in fase di compilazione.)
Quando si utilizzano raccolte non generiche, i tipi immessi nella raccolta sono oggetti di tipo Object. Pertanto, in questo esempio, a Objectè ciò che viene addinserito nel set.
set.add(10);
set.add(42);
Nelle righe precedenti, l'autoboxing è in gioco: il intvalore primitivo 10e 42viene autoboxed in Integeroggetti, che vengono aggiunti al file Set. Tuttavia, tieni presente che gli Integeroggetti vengono gestiti come Objects, poiché non ci sono informazioni sul tipo per aiutare il compilatore a sapere quale tipo Setdovrebbe aspettarsi.
for (Object o : set) {
Questa è la parte cruciale. Il motivo per cui il ciclo for-each funziona è perché Setimplementa l' Iterableinterfaccia, che restituisce una Iteratorcon informazioni sul tipo, se presente. ( Iterator<T>, cioè.)
Tuttavia, poiché non ci sono informazioni sul tipo, Setrestituirà an Iteratorche restituirà i valori in Setas Objects, ed è per questo che l'elemento che viene recuperato nel ciclo for-each deve essere di tipo Object.
Ora che Objectè stato recuperato da Set, è necessario Integereseguirne il cast manualmente per eseguire l'aggiunta:
total += (Integer)o;
Qui, un typecast viene eseguito da un Objecta un Integer. In questo caso, sappiamo che funzionerà sempre, ma il typecasting manuale mi fa sempre sentire che è un codice fragile che potrebbe essere danneggiato se viene apportata una piccola modifica altrove. (Sento che ogni typecast è in ClassCastExceptionattesa che accada, ma sto divagando ...)
Il Integerè ora unboxed in un inte consentito di eseguire l'aggiunta nella intvariabile total.
Spero di poter illustrare che le nuove funzionalità di Java 5 possono essere utilizzate con codice non generico, ma semplicemente non è così pulito e diretto come scrivere codice con generici. E, a mio parere, per sfruttare appieno le nuove funzionalità di Java 5, si dovrebbe esaminare i generici, se non altro, consentire controlli in fase di compilazione per evitare che i typecast non validi generino eccezioni in fase di esecuzione.