eBook Gratis

In questo libro il lettore potrà apprendere i fondamenti della programmazione Java dal noto esperto di programmazione Herbert Schildt.
Aggiornata all'ultima versione di Java (Java SE 6), questa guida passo passo insegna a programmare in Java a partire dalle basi. Si inizia spiegando perché Java è il linguaggio di programmazione per Internet più diffuso, per poi illustrare in che modo è legato alla programmazione a oggetti (OOP) e la forma generale di un programma Java.
Si passa poi a vedere che cosa sono i tipi di dati, gli operatori, le istruzioni di controllo, le classi, gli oggetti e i metodi, quindi si apprendono i concetti riguardanti ereditarietà, gestione delle eccezioni, sistema di I/O e multithreading.
Nel libro si affrontano argomenti come generics, interfacce, applet ed enumerazioni.
Il volume termina quindi con un'introduzione a Swing, il potente strumento GUI per la programmazione Java. Con questo testo, pratico e semplice, potrete iniziare fin da subito a programmare in Java.

L'autore
Herbert Schildt è un’autorità per Java, C, C++ e C#. I suoi libri sulla programmazione hanno venduto oltre tre milioni e mezzo di copie in tutto il mondo e sono stati tradotti nelle principali lingue. È autore di numerosi bestseller.
Grazie alla sua lunga esperienza nella scrittura di testi ha raggiunto un metodo di esposizione ottimale per chi deve imparare un linguaggio, anche nel trasferire concetti complessi. L’utilizzo sapiente dei tutorial trasforma i suoi testi in perfette guide passo-passo.

INTRODUZIONE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XV
1 Nozioni fondamentali su Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Origini di Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Relazione di Java con C e C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Relazione di Java con C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Contributo di Java a Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Applet Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Sicurezza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Portabilità . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Bytecode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Caratteristiche di Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Programmazione orientata agli oggetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Incapsulamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Polimorfismo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Ereditarietà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Java Development Kit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Un primo semplice programma. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Inserimento del programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Compilazione del programma. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Il primo programma di esempio riga per riga . . . . . . . . . . . . . . . . . . . . . . . . 13
Un secondo semplice programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Progetto 1.1 Conversione di galloni in litri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Due istruzioni di controllo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Istruzione if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Ciclo for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Creare blocchi di codice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Punto e virgola e posizionamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Progetto 1.2 Perfezionamento del convertitore galloni-litri. . . . . . . . . . . . . . . . . . . . 28
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Parole chiave di Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Identificatori in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Modulo 1 – Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

2 Introduzione ai tipi di dati e operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Importanza dei tipi di dati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Tipi primitivi di Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Interi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Tipi in virgola mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Caratteri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Tipo boolean . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Progetto 2.1 Quanto è lontano il fulmine? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Valori letterali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Costanti esadecimali e ottali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Sequenze di escape dei caratteri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Valori letterali stringa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Approfondimento sulle variabili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Inizializzazione di una variabile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Inizializzazione dinamica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Area di validità e durata delle variabili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Operatori aritmetici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Incremento e decremento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Operatori relazionali e logici. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Operatori logici abbreviati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Operatore di assegnazione. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
Assegnazioni abbreviate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Conversione del tipo nelle assegnazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
Conversione esplicita di tipi incompatibili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
Precedenza degli operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Progetto 2.2 Visualizzare una tabella della verità per gli operatori logici . . . . . . . . . 61
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Espressioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Conversione del tipo nelle espressioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Spaziatura e parentesi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Modulo 2 – Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

3 Istruzioni di controllo del programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
Immettere caratteri dalla tastiera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
Istruzione if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Istruzioni if nidificate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
Scala if-else-if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Istruzione switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Istruzioni switch nidificate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Progetto 3.1 Iniziare a creare un sistema di guida per Java . . . . . . . . . . . . . . . . . . . . 77
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Ciclo for. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Alcune variazioni del ciclo for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Parti mancanti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Cicli senza corpo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Dichiarazioni delle variabili di controllo del ciclo nel ciclo for . . . . . . . . . . 85
Ciclo for avanzato . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Ciclo while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Ciclo do-while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Progetto 3.2 Migliorare il sistema di guida per Java . . . . . . . . . . . . . . . . . . . . . . . . . 90
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Utilizzare break per uscire da un ciclo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Utilizzare break come forma di goto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Utilizzare continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Progetto 3.3 Terminare il sistema di guida per Java. . . . . . . . . . . . . . . . . . . . . . . . . 101
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
Cicli nidificati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
Modulo 3 – Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

4 Introduzione a classi,oggetti e metodi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
Nozioni fondamentali sulle classi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
Forma generica di una classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
Definizione di una classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Modalità di creazione degli oggetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Variabili di riferimento e assegnazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Metodi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Aggiunta di un metodo alla classe Vehicle . . . . . . . . . . . . . . . . . . . . . . . . . 115
Ritorno al chiamante da un metodo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Restituzione di un valore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
Utilizzo dei parametri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Aggiunta di un metodo con parametri a Vehicle. . . . . . . . . . . . . . . . . . . . . 122
Progetto 4.1 Creazione di una classe di guida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
Costruttori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
Costruttori con parametri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
Aggiunta di un costruttore alla classe Vehicle . . . . . . . . . . . . . . . . . . . . . . 131
Operatore new rivisitato . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
Garbage collection e finalizzatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
Metodo finalize( ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
Progetto 4.2 Dimostrare la finalizzazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Parola chiave this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
Modulo 4 – Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

5 Altri tipi di dati e operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Array unidimensionali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Ordinare un array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Array multidimensionali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
Array bidimensionali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
Array irregolari . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Array di tre o più dimensioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
Inizializzazione di array multidimensionali . . . . . . . . . . . . . . . . . . . . . . . . 151
Sintassi alternativa per la dichiarazione di array. . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
Assegnazione di riferimenti agli array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
Utilizzo del membro length. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
Progetto 5.1 Una classe Queue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
Ciclo for in stile for-each. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
Iterazione negli array multidimensionali . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Applicazione del ciclo for avanzato . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
Stringhe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
Creazione di stringhe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
Gestione di oggetti String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
Array di stringhe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
Stringhe invariabili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
Utilizzo di argomenti della riga di comando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
Operatori sui bit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
Operatori AND, OR, XOR e NOT sui bit . . . . . . . . . . . . . . . . . . . . . . . . . . 174
Operatori di scorrimento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
Assegnazioni abbreviate sui bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
Progetto 5.2 Una classe ShowBits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
Operatore ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
Modulo 5 – Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186

6 Approfondimento su metodi e classi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
Controllo dell’accesso ai membri delle classi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
Specificatori di accesso in Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
Progetto 6.1 Perfezionamento della classe Queue . . . . . . . . . . . . . . . . . . . . . . . . . . 195
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
Passare oggetti ai metodi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Modalità di passaggio degli argomenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
Restituzione degli oggetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
Overload dei metodi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
Overload dei costruttori. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
Progetto 6.2 Overload del costruttore Queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Ricorsione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
Comprensione di static . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
Blocchi static. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
Progetto 6.3 Quick sort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Introduzione alle classi nidificate e interne. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
Vararg: argomenti di lunghezza variabile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
Nozioni di base su vararg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
Overload dei metodi vararg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
Vararg e ambiguità . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
Modulo 6 – Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233

7 Ereditarietà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
Nozioni di base sull’ereditarietà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
Accesso ai membri ed ereditarietà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
Costruttori ed ereditarietà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
Utilizzo di super per chiamare i costruttori di superclasse . . . . . . . . . . . . . 243
Utilizzo di super per accedere ai membri di superclasse. . . . . . . . . . . . . . . . . . . . . . 248
Progetto 7.1 Estensione della classe Vehicle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
Creazione di una gerarchia a più livelli. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
Momento di chiamata dei costruttori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
Riferimenti di superclasse e oggetti sottoclasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
Overriding dei metodi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
Supporto del polimorfismo nei metodi con overridde . . . . . . . . . . . . . . . . . . . . . . . 264
Motivi per l’overridde dei metodi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
Applicazione dell’override dei metodi a TwoDShape . . . . . . . . . . . . . . . . 266
Utilizzo di classi astratte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
Utilizzo di final . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
final impedisce l’overriding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
final impedisce l’ereditarietà. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
Utilizzo di final con i membri dati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
Classe Object. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
Modulo 7 – Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

8 Pacchetti e interfacce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
Pacchetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
Definizione di un pacchetto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
Individuazione di pacchetti e CLASSPATH. . . . . . . . . . . . . . . . . . . . . . . . 283
Un breve esempio sui pacchetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
Accesso a membri e pacchetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
Esempio di accesso ai pacchetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
Comprensione dei membri protetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
Importazione di pacchetti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
Pacchetti della libreria di classi di Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
Interfacce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
Implementazione delle interfacce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
Utilizzo dei riferimenti di interfaccia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
Progetto 8.1 Creazione di un’interfaccia Queue . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
Variabili nelle interfacce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
Estensione delle interfacce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
Modulo 8 – Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
9 Gestione delle eccezioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Gerarchia di eccezioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
Nozioni di base sulla gestione delle eccezioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
Utilizzo di try e catch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
Un semplice esempio di eccezione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
Conseguenze di un’eccezione non intercettata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
Eccezioni per la corretta gestione degli errori . . . . . . . . . . . . . . . . . . . . . . 316
Utilizzo di più istruzioni catch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
Intercettazione di eccezioni di sottoclasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
Nidificazione dei blocchi try . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
Generazione di un’eccezione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
Rigenerazione di un’eccezione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
Approfondimento su Throwable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
Utilizzo di finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
Utilizzo di throws . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
Eccezioni integrate in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
Creazione di sottoclassi di eccezioni. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
Progetto 9.1 Aggiunta di eccezioni alla classe Queue . . . . . . . . . . . . . . . . . . . . . . . 333
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
Modulo 9 – Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337

10 Utilizzo dell’I/O. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
I/O di Java basato sui flussi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
Flussi di byte e flussi di caratteri. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
Classi a flusso di byte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
Classi a flusso di caratteri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
Flussi predefiniti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
Utilizzo dei flussi di byte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
Lettura dell’input da console . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
Scrittura dell’output su console . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
Lettura e scrittura di file con flussi di byte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
Input da un file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
Scrittura su un file. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
Lettura e scrittura di dati binari . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
Progetto 10.1 Utility di confronto dei file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
File ad accesso casuale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
Utilizzo dei flussi di caratteri Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
Input da console con i flussi di caratteri . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
Output su console con i flussi di caratteri. . . . . . . . . . . . . . . . . . . . . . . . . . 364
I/O su file con i flussi di caratteri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
Utilizzo di FileWriter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
Utilizzo di FileReader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
Utilizzo dei wrapper di tipo in Java per la conversione di stringhe numeriche . . . . 369
Progetto 10.2 Creazione di un sistema di guida basato su disco . . . . . . . . . . . . . . . 372
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
Modulo 10 – Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378

11 Programmazione multithread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
Nozioni fondamentali sul multithreading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
Classe Thread e interfaccia Runnable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
Creazione di un thread. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
Alcuni semplici miglioramenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
Progetto 11.1 Estensione di Thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
Creazione di più thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392
Determinazione della conclusione di un thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394
Priorità dei thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
Sincronizzazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
Utilizzo di metodi sincronizzati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
Istruzione synchronized. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404
Comunicazione tra thread con notify( ), wait( ) e notifyAll( ) . . . . . . . . . . . . . . . . . 407
Esempio di utilizzo di notify( ), wait( ) e notifyAll( ) . . . . . . . . . . . . . . . . 408
Sospensione, ripresa e interruzione dei thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
Progetto 11.2 Utilizzo del thread principale. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
Modulo 11 – Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419

12 Enumerazioni, autoboxing e importazione statica. . . . . . . . . . . . . . . . . . . . . . . . . . . 421
Enumerazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422
Nozioni fondamentali sulle enumerazioni . . . . . . . . . . . . . . . . . . . . . . . . . 423
Enumerazioni di Java come tipi di classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
Metodi values( ) e valueOf( ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
Costruttori, metodi, variabili di istanza ed enumerazioni . . . . . . . . . . . . . . . . . . . . . 428
Due limitazioni importanti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
Eredità di enum nelle enumerazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430
Progetto 12.1 Semaforo computerizzato . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
Autoboxing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
Wrapper di tipo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
Nozioni fondamentali sull’autoboxing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
Autoboxing e metodi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
Autoboxing/unboxing nelle espressioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
Avvertenza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444
Importazione statica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
Annotazioni (o metadati). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448
Modulo 12 – Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451

13 Elementi generici. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453
Nozioni fondamentali sugli elementi generici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
Un semplice esempio di elemento generico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455
Utilizzo degli elementi generici solo con gli oggetti . . . . . . . . . . . . . . . . . 459
Differenze tra tipi generici in base agli argomenti di tipo . . . . . . . . . . . . . 459
Classe generica con due parametri di tipo . . . . . . . . . . . . . . . . . . . . . . . . . 459
Forma generale di una classe generica . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
Tipi vincolati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462
Utilizzo di argomenti jolly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 466
Caratteri jolly vincolati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469
Metodi generici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
Costruttori generici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474
Interfacce generiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
Progetto 13.1 Creare una coda generica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478
Tipi raw e codice precedente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483
Cancellazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486
Errori di ambiguità . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487
Alcune limitazioni generiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488
Impossibilità di istanziare i parametri di tipo . . . . . . . . . . . . . . . . . . . . . . . 488
Limitazioni sui membri statici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489
Limitazioni sugli array generici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489
Limitazioni sulle eccezioni generiche. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
Modulo 13 – Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491

14 Applet, eventi e argomenti vari . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493
Nozioni fondamentali sulle applet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494
Organizzazione delle appleted elementi essenziali . . . . . . . . . . . . . . . . . . . . . . . . . . 497
Architettura delle applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497
Struttura completa di un’applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
Inizializzazione e conclusione delle applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499
Richiesta di repainting. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
Metodo update( ). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501
Progetto 14.1 Una semplice applet banner. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502
Utilizzo della finestra di stato . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506
Passaggio di parametri alle applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506
La classe Applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508
Gestione degli eventi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
Modello di eventi di delega . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
Eventi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511
Origini degli eventi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511
Listener di eventi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511
Classi di eventi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512
Interfacce dei listener di eventi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512
Utilizzo del modello di eventi di delega . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514
Gestione degli eventi del mouse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514
Una semplice applet con evento del mouse . . . . . . . . . . . . . . . . . . . . . . . . 515
Altre parole chiave di Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
Modificatori transient e volatile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
instanceof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519
strictfp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519
assert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519
Metodi nativi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520
Modulo 14 – Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522

15 Introduzione a Swing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523
Origini e filosofia di progettazione di Swing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524
Componenti e contenitori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526
Componenti. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
Contenitori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
Riquadri contenitore di primo livello . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528
Gestori di layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528
Un primo semplice programma Swing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530
Il primo esempio Swing riga per riga . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
Utilizzare JButton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535
Utilizzare JTextField . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 540
Creare un JCheckBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544
Lavorare con JList. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548
Progetto 15.1 Utility di confronto dei file basata su Swing . . . . . . . . . . . . . . . . . . . 552
Passo per passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
Utilizzare classi interne anonime per gestire gli eventi. . . . . . . . . . . . . . . . . . . . . . . 559
Creare un’applet Swing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 560
Per proseguire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 562
Modulo 15 – Verifica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563

A Risposte alle verifiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565
Modulo 1: Nozioni fondamentali su Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566
Modulo 2: Introduzione ai tipi di dati e operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . 568
Modulo 3: Istruzioni di controllo del programma . . . . . . . . . . . . . . . . . . . . . . . . . . . 570
Modulo 4: Introduzione a classi, oggetti e metodi . . . . . . . . . . . . . . . . . . . . . . . . . . 573
Modulo 5: Altri tipi di dati e operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 574
Modulo 6: Approfondimento su metodi e classi . . . . . . . . . . . . . . . . . . . . . . . . . . . . 579
Modulo 7: Ereditarietà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584
Modulo 8: Pacchetti e interfacce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586
Modulo 9: Gestione delle eccezioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588
Modulo 10: Utilizzo dell’I/O. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591
Modulo 11: Programmazione multithread. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 595
Modulo 12: Enumerazioni, autoboxing e importazione statica. . . . . . . . . . . . . . . . . 598
Modulo 13: Elementi generici. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602
Modulo 14: Applet, eventi e argomenti vari . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
Modulo 15: Introduzione a Swing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 612

B Utilizzo dei commentidi documentazione Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
Tag di javadoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 622
@author. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623
{@code} . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623
@deprecated . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623
{@docRoot} . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623
@exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624
{@inheritDoc} . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624
{@link}. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624
{@linkplain}. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624
{@literal} . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624
@param. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624
@return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
@see . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
@serial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
@serialData. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
@serialField . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
@since. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 626
@throws . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 626
{@value} . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 626
@version . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 626
Forma generica di un commento di documentazione . . . . . . . . . . . . . . . . . . . . . . . . 626
Output di javadoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 627
Esempio che utilizza i commenti di documentazione . . . . . . . . . . . . . . . . . . . . . . . . 627

Indice analitico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629