eBook Gratis

Imparate a programmare in Java con Herbert Schildt, esperto programmatore e autore di libri di grande successo.
Completamente aggiornata per includere la piattaforma Java Standard Edition 5 (J2SE 5), questa guida passo per passo vi insegnerà a programmare in breve tempo.
Partendo dalle basi, capirete il motivo per cui Java è il linguaggio preminente di Internet, come si relaziona alla programmazione orientata agli oggetti (OOP) e la forma generale di un programma Java, inclusi i tipi di dato, gli operatori, le dichiarazioni di controllo del programma, le classi, gli oggetti, i metodi.
Passerete poi ad argomenti più avanzati, come l’ereditarietà, la gestione delle eccezioni, il sistema I/O, il multithread, gli applet e molto altro.
Herbert Schildt descrive anche le nuove funzionalità aggiunte dal J2SE 5, come ad esempio i generici, l’autoboxing, le enumerazioni e l’importazione statica. Iniziate oggi a programmare in Java con questo libro semplice e facile da seguire.

L'autore
Herbert Schildt è autore di spicco su Java, C, C++ e C#. I suoi libri di programmazione sono stati venduti in più di 3 milioni di copie nel mondo e sono stati tradotti in tutte le lingue più diffuse. Ha all’attivo numerosi libri di grande successo quali la Guida Completa a Java, la Guida Completa al C, la Guida Completa a C++.

Prefazione
Java è il linguaggio preminente di Internet. Inoltre, è il linguaggio universale di molti programmatori Web di tutto il mondo. Essere un professionista del Web oggi implica una certa dimestichezza con Java. Perciò, se la programmazione basata su Internet è il vostro futuro, avete scelto il linguaggio di apprendimento giusto e questo libro vi aiuterà a conoscerlo.
Lo scopo di questo libro è insegnarvi i fondamenti della programmazione in Java. Esso utilizza un approccio passo per passo, completo di molti esempi, prove e progetti. Si presuppone che non abbiate alcuna esperienza nella programmazione. Il libro inizia con le nozioni di base, ad esempio come compilare ed eseguire un programma Java. Quindi, illustra ogni parola chiave del linguaggio Java. Si conclude con alcune delle funzionalità Java più avanzate, come ad esempio la programmazione multithreaded, basata sui generics e la creazione delle applet. Una volta letto questo libro, avrete compreso le nozioni essenziali della programmazione in Java.
È importante spiegare che questo libro costituisce solo un punto di partenza. Java è molto più degli elementi che definiscono il linguaggio. Include anche diverse librerie e strumenti che aiutano nello sviluppo dei programmi. Inoltre, Java fornisce un gruppo sofisticato di librerie che gestiscono l’interfaccia utente del browser. Essere un esperto programmatore Java significa conoscere a fondo anche queste parti. Leggendo questo libro, avrete le conoscenze fondamentali per gestire qualunque aspetto di Java.

L’evoluzione di Java
Solo alcuni linguaggi fondamentalmente hanno riforgiato la vera essenza della programmare. In questo gruppo d’élite, uno di essi è in primo piano, perché il suo impatto è stato rapido e molto esteso. Questo linguaggio è, chiaramente, Java. Non è un’esagerazione affermare che il rilascio di Java 1.0 nel 1995 da parte di Sun Microsystems provocò una rivoluzione nella programmazione. Questa rivoluzione trasformò radicalmente il Web in un ambiente estremamente interattivo. In questo processo, Java stabilì un nuovo standard nel design del linguaggio a computer.
Durante il corso degli anni, Java ha continuato a crescere, evolvere, e a ridefinirsi. A differenza di altri linguaggi, che sono lenti ad incorporare nuove funzionalità, Java è stato continuamente in prima linea nel design del linguaggio a computer. Uno dei motivi è la cultura dell’innovazione e i cambiamenti che sono avvenuti intorno a Java. Di conseguenza, Java ha avuto molti aggiornamenti, alcuni secondari, altri più significativi. Il primo importante aggiornamento di Java è stata la versione 1.1. Le funzionalità aggiunte da Java 1.1 erano più sostanziali dell’esiguo aumento nel numero di versione. Ad esempio, Java 1.1 aveva molti elementi nuovi nella libreria, aveva ridefinito la gestione degli eventi e riconfigurato molte funzionalità della libreria originale della versione 1.0.
Il successivo aggiornamento di rilievo di Java è stato Java 2, dove il 2 indica “seconda generazione.” Lo sviluppo di Java 2 è stato un evento spartiacque, stabilendo l’inizio dell’“età moderna” di Java. Il primo rilascio di Java 2 portava la versione numero 1.2. Può sembrare strano che la prima versione di Java 2 avesse il numero 1.2. Originariamente il numero si riferiva alla versione interna delle librerie di Java, generalizzato all’intera versione del linguaggio. Con Java 2, Sun ha ribattezzato il prodotto come J2SE (Java 2 Platform Standard Edition), e da quel momento è iniziata l’applicazione dei numeri di versione.
Un aggiornamento successivo di Java è stato J2SE 1.3. Questa versione di Java è stato il primo aggiornamento importante a Java 2. In gran parte dedicato ad aggiunte alle funzionalità esistenti e focalizzando l’attenzione sull’ambiente di sviluppo. Il rilascio di J2SE 1.4 ha ulteriormente migliorato Java. Questa versione contiene molte importanti nuove funzionalità, come le eccezioni concatenate, I/O basato sul canale, e la parola chiave assert.
L’ultima release di Java è J2SE 5. Sebbene ogni aggiornamento precedente di Java sia stato importante, nessuno di essi però avvicina in scala, dimensioni e validità J2SE 5. Questa versione ha fondamentalmente riformato il mondo di Java!

J2SE 5: la seconda rivoluzione di Java
Java 2 Platform Standard Edition, versione 5 (J2SE 5) segna l’inizio della seconda rivoluzione di Java. J2SE 5 aggiunge molte funzionalità nuove a Java che fondamentalmente cambiano il carattere del linguaggio, aumentando la sua potenza e i campi di applicazione. Queste aggiunte sono così profonde che modificheranno per sempre il modo in cui è scritto il codice di Java. J2SE 5 è una forza rivoluzionaria che non può essere ignorata.

Per dare un’idea della vastità delle modifiche introdotte da J2SE 5, ecco un elenco delle principali nuove caratteristiche, descritte in questo libro:
- Generics
- Enumerazioni
- Autoboxing/unboxing
- Il ciclo enhanced for
- Numero variabile di argomenti (varargs)
- Importazione statica
- Metadati (note)

Questo non è un elenco migliorie minori o aggiornamenti incrementali. Ogni elemento nell’elenco rappresenta un’aggiunta significativa al linguaggio di Java. Alcuni di essi, come i generics, il ciclo enhanced for e i varargs, presentano nuovi elementi di sintassi . Altri, come l’autoboxing e l’auto-unboxing, modificano la semantica del linguaggio. I metadati infine aggiungono una dimensione completamente nuova alla programmazione. In generale, sono state aggiunte delle funzionalità sostanziali.
L’importanza di queste nuove funzionalità è riflessa nell’uso della versione numero 5. Il successivo numero di versione per Java avrebbe dovuto essere l’1.5. Tuttavia, le modifiche e le nuove caratteristiche sono così significative che un cambiamento da 1.4 a 1.5 non è stato ritenuto sufficiente ad esprimere in modo chiaro l’importanza dell’aggiornamento. Così Sun ha deciso di aumentare il numero di versione a 5 come se volesse in qualche modo enfatizzare che era avvenuto un evento di grande importanza. Ecco perché il prodotto corrente stato chiamato J2SE 5, e il kit dello sviluppatore èstato chiamato JDK 5. Comunque per mantenere consistenza, Sun ha deciso decise di mantenere 1.5 come proprio numero di versione interno. Così, 5 è il numero di versione esterno e 1.5 è il numero di versione interno.

Dato che Sun usa l’1.5 come il numero di versione interno, quando si chiede al compilatore la sua versione, esso restituirà 1.5 invece che 5. Anche la documentazione on-line fornita da Sun indica l’1.5 per riferirsi alle caratteristiche aggiunte da J2SE 5. In generale, ogni qualvolta si vede la versione 1.5, si deve intendere semplicemente 5. Questo libro è stato completamente aggiornato per includere le caratteristiche nuove aggiunte da J2SE 5. Per gestire tutto il nuovo materiale, a qusta edizione sono stati aggiunti due moduli completamente nuovi. Il Modulo 12 descrive le enumerazioni, l’autoboxing, l’importazione statica e i metadati. Il Modulo 13 esamina invece i generics. Le descrizioni dello stile “for-each” del ciclo for e il tema del numero di argomenti variabile sono state integrate nei moduli già esistenti.

Come è organizzato questo libro.
Questo libro ha una struttura didattica illustrata in modo uniforme, in cui ogni paragrafo segue quello precedente. Contiene 14 moduli, ognuno dei quali illustra un aspetto di Java. Questo libro è davvero unico, poiché include molti elementi speciali che spiegano ulteriormente ciò che state apprendendo.

Obiettivi
Ogni modulo si apre con la spiegazione delle capacità di programmazione che saranno acquisite al termine del capitolo.
Verifica finale
Ogni modulo termina con una Verifica, un auto-test che permette di mettere alla prova le tue conoscenze. Le risposte si trovano nell’Appendice A.
Esercitazione flash
Alla fine di ogni paragrafo principale si trova una “Esercitazione flash”, che mette alla prova la tua comprensione dei punti chiave illustrati. Le risposte a queste domande si trovano in fondo alla pagina.
Domande all’esperto
Sparse in tutto il libro vi sono speciali riquadri “Domande all'esperto”. Essi contengono informazioni aggiuntive o commenti interessanti su un determinato argomento. Utilizzano un formato domanda-risposta.
Progetti
Ogni modulo contiene uno o più progetti che illustrano come applicare ciò che si sta imparando. Si tratta di esempi reali, da utilizzare come punto di partenza per la propria programmazione.

Nessuna precedente esperienza di programmazione richiesta Questo libro presuppone che non abbiate alcuna esperienza di programmazione, anche se, sicuramente, al giorno d’oggi la maggior parte dei lettori avrà già avuto a che fare con la programmazione. Se avete già una precedente esperienza di programmazione, sarete in grado di avanzare più rapidamente. Tenete presente tuttavia che Java differisce in molti punti chiave da altri linguaggi di programmazione al computer. È importante non saltare direttamente alle conclusioni. Un’attenta lettura è consigliata anche per i programmatori più esperti.

Software richiesto Per compilare ed eseguire i programmi di questo libro occorre avere l’ultimo Java Development Kit (JDK) della Sun, che (al momento della stesura) è Java 2Platform Standard Edition versione 5 (J2SE 5). Le istruzioni per prelevare il JDK vengono fornite nel Modulo 1. Se state usando una precedente versione di Java, come ad esempio J2SE 1.4, sarete comunque in grado di utilizzare questo libro, ma non potrete compilare ed eseguire i programmi che fanno uso delle nuove funzionalità aggiunte da J2SE 5.
Non dimenticate: il codice sul Web Il codice sorgente di tutti gli esempi e i progetti di questo libro è disponibile gratuitamente sul Web, all’indirizzo www.informatica.mcgraw-hill.it.

PREFAZIONE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xvii

1 Fondamentali di Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Le origini di Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Come Java si relaziona a C e C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Come Java si relaziona a C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Il contributo di Java a Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Applet Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Sicurezza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Portabilità . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Il bytecode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Le caratteristiche di Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Programmazione orientata agli oggetti. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Incapsulamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Polimorfismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Ereditarietà. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Il Java Development Kit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Un primo semplice programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Inserire il programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Compilare il programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Il primo programma di esempio riga per riga . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Gestire gli errori di sintassi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Un secondo semplice programma di esempio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Un altro tipo di dati. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Progetto 1.1 Convertire i galloni in litri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Due dichiarazioni di controllo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
La dichiarazione if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Il ciclo for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Creare blocchi di codice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Posizionamento e punto e virgola . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Rientri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Progetto 1.2 Migliorare il convertitore galloni-litri . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Le parole chiave di Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Identificatori in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Librerie delle classi di Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Modulo 1 Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2 Introduzione ai tipi di dati e agli operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Perché i tipi di dati sono importanti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Tipi di dati primitivi Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Numeri interi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Tipi di dati a virgola mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Caratteri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Tipo di dati boolean . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Progetto 2.1 Quanto è lontano un fulmine? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Valori letterali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Costanti esadecimali e ottali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Sequenze del carattere escape . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Stringhe letterali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Un approfondimento sulle variabili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Inizializzare una variabile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Inizializzazione dinamica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
L’area di validità e la durata delle variabili. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Operatori aritmetici. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Incremento e decremento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
Operatori relazionali e logici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Operatori logici cortocircuito . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
L’operatore di assegnazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
Assegnazioni shorthand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Conversione del tipo di assegnazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Il cast nei tipi non compatibili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Precedenza di operatore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Progetto 2.2 Visualizzare una tabella per gli operatori logici . . . . . . . . . . . . . . . . . . 65
Espressioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
Conversione di tipo nelle espressioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
Spaziatura e parentesi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
Modulo 2 Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
3 Dichiarazioni di controllo del programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
Caratteri di input da tastiera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
La dichiarazione if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Gli if annidati. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
L’istruzione if-else-if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
La dichiarazione switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Dichiarazioni switch annidate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Progetto 3.1 Iniziare a creare un sistema di aiuto di Java . . . . . . . . . . . . . . . . . . . . . 83
Il ciclo for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Alcune variazioni sul ciclo for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Parti mancanti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Cicli senza corpo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Dichiarare variabili di controllo del ciclo nel ciclo for . . . . . . . . . . . . . . . . . . . 91
Il ciclo Enhanced for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Il ciclo while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Il ciclo do-while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Progetto 3.2 Migliorare il sistema di aiuto di Java . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Usare break per uscire da un ciclo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Usare break come una forma di goto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Usare continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
Progetto 3.3 Terminare il sistema di aiuto di Java . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Cicli annidati. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
Modulo 3 Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
4 Classi, oggetti e metodi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Fondamentali della classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
La forma generale di una classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
Definire una classe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Come vengono creati gli oggetti. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Variabili di riferimento e assegnazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Metodi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
Aggiungere un metodo alla classe Vehicle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
Restituzione di un metodo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
Restituzione di un valore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
I parametri. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
Aggiungere un metodo con parametro a Vehicle. . . . . . . . . . . . . . . . . . . . . . . . 130
Progetto 4.1 Creare una classe Help . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
Costruttori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
Costruttori con parametro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
Aggiungere un costruttore alla classe Vehicle . . . . . . . . . . . . . . . . . . . . . . . . . 141
L’operatore new rivisitato . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Garbage collection e finalizer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Il metodo finalize( ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
Progetto 4.2 Dimostrare la finalizzazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
La parola chiave this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Modulo 4 Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
5 Alti tipi di dati e operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
Gli array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
Array a una dimensione. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
Progetto 5.1 Ordinare un array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
Array multidimensionali. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
Array a due dimensioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
Array irregolari . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
Array di tre o più dimensioni. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
Inizializzare gli array multidimensionali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
Sintassi alternativa per la dichiarazione di array . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
Assegnare riferimenti di array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Il membro length . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
Progetto 5.2 Una classe Queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
Lo stile for-each per il ciclo for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
Iterazioni di array multidimensionali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Applicazioni del ciclo Enhanced for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
String. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
Creare String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
Lavorare sulle stringhe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
Array di stringhe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
Le stringhe non cambiano . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
Gli argomenti a riga di comando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
Gli operatori bitwise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Gli operatori bitwise AND, OR, XOR e NOT. . . . . . . . . . . . . . . . . . . . . . . . . . 186
Gli operatori con spostamento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
Assegnazioni shorthand bitwise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
Progetto 5.3 Una classe ShowBits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
L’operatore ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
Modulo 5 Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
6 I metodi e le classi in dettaglio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
Controllare l’accesso ai membri della classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
Gli specificatori di accesso in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
Progetto 6.1 Migliorare la classe Queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
Passare oggetti ai metodi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
Come vengono passati gli argomenti. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Restituire gli oggetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
Sovraccaricare i metodi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
Sovraccaricare i costruttori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
Progetto 6.2 Sovraccaricare il costruttore Queue . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
La ricorsione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
Comprendere static . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
I blocchi static . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
Progetto 6.3 Il Quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
Introduzione alle classi annidate e interne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
Vararg: Numero variabile di argomenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
Basi di vararg. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
Sovraccaricare i metodi vararg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
Vararg e ambiguità. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
Modulo 6 Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
7 Ereditarietà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
Fondamentali dell’ereditarietà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
Accesso al membro ed ereditarietà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
Costruttori ed ereditarietà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
Usare super per chiamare i costruttori della superclasse . . . . . . . . . . . . . . . . . . 260
Usare super per accedere ai membri della superclasse . . . . . . . . . . . . . . . . . . . . . . . 266
Progetto 7.1 Ampliare la classe Vehicle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
Creare una gerarchia a più livelli . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
Quando vengono chiamati i costruttori?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
Riferimenti alla superclasse e oggetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
di superclasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Escludere un metodo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
I metodi esclusi supportano il polimorfismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
Perché escludere i metodi? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
Applicare l’esclusione di un metodo a TwoDShape . . . . . . . . . . . . . . . . . . . . . 285
Usare le classi astratte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
Usare final. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
final impedisce l’esclusione. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
final impedisce l’ereditarietà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
Usare final con i membri dei dati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
La classe Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
Modulo 7 Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
8 Pacchetti e interfacce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301
Pacchetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
Definire un pacchetto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
Trovare i pacchetti e CLASSPATH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
Un breve esempio di pacchetto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
Pacchetti e accesso ai membri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
Un esempio di accesso al pacchetto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
I membri protetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Importare i pacchetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
La libreria delle classi Java è contenuta in pacchetti . . . . . . . . . . . . . . . . . . . . . . . . . 314
Interfacce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315
Implementare le interfacce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
Usare i riferimenti di interfaccia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
Progetto 8.1 Creare un’interfaccia Queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
Variabili nelle interfacce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
Le interfacce possono essere ampliate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329
Modulo 8 Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
9 Gestione delle eccesioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
La gerarchia delle eccezioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
La gestione delle eccezioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
Usare try e catch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
Un semplice esempio di eccezione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
Le conseguenze di un’eccezione non catturata. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
Le eccezioni permettono di gestire meglio gli errori. . . . . . . . . . . . . . . . . . . . . 340
Usare più dichiarazioni catch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
Eccezioni catch di sottoclasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
I blocchi try possono essere annidati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
Lanciare un’eccezione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
Lanciare nuovamente un’eccezione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
Throwable in dettaglio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
Usare finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
Usare throws . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
Le eccezioni incorporate di Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354
Creare sottoclassi di eccezioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
Progetto 9.1 Aggiungere le eccezioni alla classe Queue . . . . . . . . . . . . . . . . . . . . . 359
Modulo 9 Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
10 Usare l’I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365
L’I/O di Java si basa sui flussi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
Flussi di byte e flussi carattere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
Le classi con flusso di byte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
Le classi con flussi carattere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
I flussi predefiniti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
Usare i flussi di byte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
Leggere l’input da console. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
Scrivere gli output da console . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
Leggere e scrivere i file usando i flussi di byte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373
L’input da un file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
L’output a un file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376
Leggere e scrivere i dati binari . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
Progetto 10.1 L’utility di confronto dei file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
File ad accesso casuale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
Usare i flussi di Java basati basati sui caratteri. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
L’input da tastiera usando i flussi carattere . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
L’output da tastiera usando i flussi carattere . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
I/O del file usando i flussi carattere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
Usare un FileWriter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
Usare un FileReader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394
Usare il wrapper del tipo per convertire le stringhe numeriche . . . . . . . . . . . . . . . . . 396
Progetto 10.2 Creare un sistema di aiuto su disco . . . . . . . . . . . . . . . . . . . . . . . . . . 399
Modulo 10 Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
11 Programmazione multithreaded . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
Il multithread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
La classe Thread e l’interfaccia Runnable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
Creare un thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410
Alcuni semplici miglioramenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
Progetto 11.1 Ampliare Thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
Creare più thread. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
Determinare quando termina un thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
Priorità di thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
Sincronizzazione. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428
Usare i metodi di sincronizzazione. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428
La dichiarazione synchronized . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431
Comunicazione di thread usando notify( ), wait( ) e notifyAll( ) . . . . . . . . . . . . . . . . 434
Un esempio che utilizza wait( ) e notify( ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
Sospendere, riprendere e terminare i thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
Progetto 11.2 Usare il thread principale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444
Modulo 11 Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
12 Enumerazioni, Autoboxing e importazione statica. . . . . . . . . . . . . . . . . . . . . . . . . . . 447
Enumerazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448
Fondamentali delle enumerazioni. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449
Le enumerazioni Java sono tipi di classi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452
I metodi values( ) e valueOf( ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452
Costruttori, metodi, istanze di variabili ed enumerazioni. . . . . . . . . . . . . . . . . . . . . . 454
Due importanti restrizioni. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
Le enumerazioni ereditano Enum. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
Progetto 12.1 Un semaforo controllato dal computer . . . . . . . . . . . . . . . . . . . . . . . . 458
Autoboxing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464
Wrapper del tipo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465
Fondamenti dell’autoboxing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467
Autoboxing e metodi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468
L’autoboxing/unboxing nelle espressioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470
Un attimo d’attenzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
Importazione statica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472
Metadati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476
Modulo 12 Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 479
13 Generics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
Fondamentali dei generics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482
Un semplice esempio di generics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483
I generics lavorano solo con gli oggetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487
I tipi generici si differenziano in base ai loro argomenti di tipo . . . . . . . . . . . . 487
Una classe generica con due parametri di tipo . . . . . . . . . . . . . . . . . . . . . . . . . 488
La forma generale di una classe generica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490
Tipi limitati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490
Usare argomenti jolly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494
Usare argomenti jolly limitati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
Metodi generici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501
Costruttori generici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504
Interfacce generiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505
Progetto 13.1 Creare una coda generica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508
Tipi Raw e codice legacy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513
Erasure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516
Errori d’ambiguità . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
Alcune restrizioni dei generics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519
I parametri del tipo non possono essere istanziati . . . . . . . . . . . . . . . . . . . . . . . 519
Restrizioni sui membri statici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520
Restrizioni degli array generici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520
Restrizioni delle eccezioni generiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522
Proseguire lo studio sui generics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522
Modulo 13 Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522
14 Applet, eventi e argomenti vari. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 525
Le applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526
Organizzazione delle applet ed elementi essenziali . . . . . . . . . . . . . . . . . . . . . . . . . . 530
L’architettura delle applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530
Una struttura di applet completa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
Inizializzazione e interruzione delle applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532
Richiedere il ridisegno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533
Il metodo update( ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 534
Progetto 14.1 Una semplice applet per i banner . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535
Usare la finestra di stato . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539
Passare i parametri alle applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 540
La classe Applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542
Gestione degli eventi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544
Il modello di delegazione dell’evento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544
Eventi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544
Sorgenti di evento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545
Listener di evento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545
Classi di evento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545
Interfacce listener di evento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546
Usare il modello di delegazione dell’evento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548
Gestire gli eventi del mouse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548
Una semplice applet di evento del mouse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 549
Altre parole chiave di Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
I modificatori transient e volatile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
instanceof. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
strictfp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
assert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
Metodi nativi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554
E ora? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555
Modulo 14 Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556
A Risposte alle verifiche finali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557
Modulo 1: Fondamentali di Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558
Modulo 2: Introduzione ai tipi di dati e agli operatori. . . . . . . . . . . . . . . . . . . . . 560
Modulo 3: Dichiarazioni di controllo del programma. . . . . . . . . . . . . . . . . . . . . 562
Modulo 4: Classi, oggetti e metodi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565
Modulo 5: Altri tipi di dati e operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566
Modulo 6: I metodi e le classi in dettaglio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570
Modulo 7: Ereditarietà. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575
Modulo 8: Pacchetti e interfacce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577
Modulo 9: Gestione delle eccezioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 579
Modulo 10: Usare l’I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 582
Modulo 11: Programmazione multithreaded . . . . . . . . . . . . . . . . . . . . . . . . . . . 586
Modulo 12: Enumerazioni, Autoboxing e importazione statica . . . . . . . . . . . . . 588
Modulo 13: Generics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592
Modulo 14: Applet, eventi e argomenti vari . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597
B Usare i commenti della documentazione di Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
I tag javadoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 604
@author . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605
{@code} . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605
@deprecated . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605
{@docRoot} . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606
@exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606
{@inheritDoc}. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606
{@link} . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606
{@linkplain} . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606
{@literal} . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606
@param . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
@return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
@see . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
@serial. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
@serialData . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608
@serialField. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608
@since . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608
@throws. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608
{@value} . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608
@version . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609
La forma generale di un commento di documentazione. . . . . . . . . . . . . . . . . . . . . . . 609
Cosa pubblica javadoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609
Un esempio che utilizza i commenti di documentazione . . . . . . . . . . . . . . . . . . . . . . 610
Indice analitico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613