Un testo sulla programmazione e una guida per il linguaggio Java (versione 7) che accompagna al rigore dell'esposizione un'attenzione costante verso la pragmatica della programmazione.
I concetti di base della programmazione sono introdotti assieme alla parte imperativa del linguaggio; classi e oggetti sono inizialmente trattati come tipi di dati strutturati, per poi essere esplorati in tutte le loro caratteristiche. Il trattamento degli aspetti object-oriented procede di pari passo con la discussione del ruolo degli oggetti nella progettazione di sistemi complessi e nella risoluzione di problemi.
Il volume incoraggia uno stile di programmazione rivolto al problem-solving, conciliando la definizione e il rispetto di specifiche rigorose con gli aspetti pratici e stilistici.
Completano il testo esercizi e mini-progetti e utili indicazioni su come affrontare gli errori più comuni.
La nuova edizione - rivista, migliorata e arricchita negli esempi - è interamente aggiornata alla versione 7 di Java ed è indicata sia per gli esperti, sia per chi non abbia precedenti esperienze di programmazione.
Gli autori
Roberto Bruni (ricercatore), Andrea Corradini (professore associato) e Vincenzo Gervasi (ricercatore) insegnano presso il Dipartimento di Informatica dell'Università di Pisa. Roberto Bruni e Andrea Corradini sono docenti di corsi di laboratorio di programmazione in Java, Vincenzo Gervasi è docente del corso di linguaggi di sistema.
Nel CD abbinato al testo:
Java Standard Edition Development Kit 7 Preview Release, NetBeans, Eclipse IDE for Java developers.
Sommario
Prefazione xiii
Capitolo 1
Introduzione alla programmazione 1
1.1 Hardware e software . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 La programmazione . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.1 I paradigmi di programmazione . . . . . . . . . . . . . . . 4
1.2.2 Problemi, requisiti, specifiche, implementazioni . . . . . . . 6
1.2.3 La nozione di algoritmo . . . . . . . . . . . . . . . . . . . 8
1.3 I linguaggi formali . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.3.1 Le grammatiche EBNF . . . . . . . . . . . . . . . . . . . 9
1.4 Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Capitolo 2
Scrivere ed eseguire un programma Java 13
2.1 Scrittura, compilazione ed esecuzione . . . . . . . . . . . . . . . . 13
2.2 La compilazione . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2.1 L’analisi lessicale e l’analisi sintattica . . . . . . . . . . . . 17
2.2.2 I commenti e la formattazione . . . . . . . . . . . . . . . . 17
2.2.3 I token . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.4 L’analisi sintattica . . . . . . . . . . . . . . . . . . . . . . 20
2.3 L’esecuzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.4 I package e la direttiva import . . . . . . . . . . . . . . . . . . . . 23
2.5 Cosa può andare male? . . . . . . . . . . . . . . . . . . . . . . . . 25
2.6 Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Capitolo 3
Variabili e assegnamento 31
3.1 Le variabili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.1.1 Le dichiarazioni di variabili . . . . . . . . . . . . . . . . . 32
3.1.2 I nomi delle variabili . . . . . . . . . . . . . . . . . . . . . 33
3.1.3 Il tipo e la dimensione di una variabile . . . . . . . . . . . 34
3.1.4 Il contenuto di una variabile . . . . . . . . . . . . . . . . . 35
3.2 I valori di tipo primitivo e di tipo riferimento . . . . . . . . . . . . 35
3.3 L’assegnamento . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.4 Una classe di utilità e due esempi . . . . . . . . . . . . . . . . . . 41
3.4.1 La classe jbook.util.Input . . . . . . . . . . . . . . . . . . 41
3.4.2 Bevande e numeri magici . . . . . . . . . . . . . . . . . . 42
3.4.3 La media aritmetica e la media armonica . . . . . . . . . . 44
3.5 Le costanti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.6 Il confronto per identità e per uguaglianza . . . . . . . . . . . . . . 46
3.7 Cosa può andare male? . . . . . . . . . . . . . . . . . . . . . . . . 48
3.8 Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Capitolo 4
Alcuni tipi di dati fondamentali 55
4.1 I tipi primitivi, i letterali, le classi involucro e le API . . . . . . . . 56
4.2 I tipi numerici . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.2.1 Gli interi . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.2.2 I numeri decimali in virgola mobile . . . . . . . . . . . . . 61
4.2.3 La conversione di tipo . . . . . . . . . . . . . . . . . . . . 63
4.2.4 Le costanti letterali numeriche . . . . . . . . . . . . . . . . 66
4.3 I caratteri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.3.1 Le costanti letterali di tipo char . . . . . . . . . . . . . . . 69
4.3.2 Alcuni metodi e costanti della classe Character . . . . . . . 70
4.3.3 La conversione tra caratteri e numeri . . . . . . . . . . . . 71
4.4 I booleani . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
4.5 Le sequenze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
4.5.1 Le sequenze di lunghezza fissata: gli array . . . . . . . . . 74
4.5.2 Le sequenze di caratteri: String e StringBuffer . . . . . . . 82
4.5.3 Le sequenze di lunghezza variabile: Vector e ArrayList . . . 88
4.6 I tipi enumerativi . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
4.7 Cosa può andare male? . . . . . . . . . . . . . . . . . . . . . . . . 94
4.8 Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Capitolo 5
Espressioni 101
5.1 Le espressioni e il type checking . . . . . . . . . . . . . . . . . . . 101
5.1.1 La sintassi delle espressioni . . . . . . . . . . . . . . . . . 102
5.1.2 Valutare un’espressione . . . . . . . . . . . . . . . . . . . 105
5.1.3 Assegnare il tipo a un’espressione . . . . . . . . . . . . . . 106
5.2 Gli operatori del linguaggio . . . . . . . . . . . . . . . . . . . . . 108
5.2.1 Le caratteristiche degli operatori . . . . . . . . . . . . . . . 108
5.2.2 Gli operatori aritmetici (e la concatenazione di stringhe) . . 111
5.2.3 Gli operatori di confronto. . . . . . . . . . . . . . . . . . . 114
5.2.4 Gli operatori di uguaglianza . . . . . . . . . . . . . . . . . 115
5.2.5 Gli operatori logici . . . . . . . . . . . . . . . . . . . . . 117
5.2.6 Gli operatori bit-a-bit . . . . . . . . . . . . . . . . . . . . 118
5.2.7 Gli operatori di assegnamento . . . . . . . . . . . . . . . . 119
5.2.8 Altri operatori . . . . . . . . . . . . . . . . . . . . . . . . 120
5.3 Alcune operazioni di libreria . . . . . . . . . . . . . . . . . . . . . 121
5.3.1 Operazioni aritmetiche su oggetti . . . . . . . . . . . . . . 121
5.3.2 La classe Math . . . . . . . . . . . . . . . . . . . . . . . . 122
5.4 Cosa può andare male? . . . . . . . . . . . . . . . . . . . . . . . . 124
5.5 Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
Capitolo 6
Comandi e strutture di controllo 127
6.1 I blocchi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
6.1.1 Ambito di visibilità delle variabili locali . . . . . . . . . . . 128
6.2 Gli assegnamenti e altri comandi espressione . . . . . . . . . . . . 133
6.3 I comandi condizionali . . . . . . . . . . . . . . . . . . . . . . . . 133
6.3.1 Il comando if-else . . . . . . . . . . . . . . . . . . . . . . 135
6.3.2 Il comando switch . . . . . . . . . . . . . . . . . . . . . . 138
6.3.3 Cosa può andare male? . . . . . . . . . . . . . . . . . . . 143
6.3.4 Esercizi su comandi condizionali . . . . . . . . . . . . . . 145
6.4 I comandi iterativi . . . . . . . . . . . . . . . . . . . . . . . . . . 146
6.4.1 Il comando while . . . . . . . . . . . . . . . . . . . . . . 147
6.4.2 Il comando do-while . . . . . . . . . . . . . . . . . . . . . 152
6.4.3 Il comando for . . . . . . . . . . . . . . . . . . . . . . . . 153
6.4.4 L’iterazione determinata su array e il comando for-each . . . 156
6.4.5 Le istruzioni iterative a confronto . . . . . . . . . . . . . . 160
6.4.6 Cosa può andare male? . . . . . . . . . . . . . . . . . . . 161
6.4.7 Esercizi su comandi iterativi . . . . . . . . . . . . . . . . . 165
6.5 I comandi etichettati, break e continue . . . . . . . . . . . . . . . . 167
6.6 Schemi di programmi iterativi . . . . . . . . . . . . . . . . . . . . 168
6.6.1 Scansione di una sequenza: calcolo del massimo . . . . . . 168
6.6.2 Cicli annidati: riempimento di array con controllo sui valori 169
6.6.3 Inversione di un array . . . . . . . . . . . . . . . . . . . . 172
6.6.4 Ordinamento di un array . . . . . . . . . . . . . . . . . . . 172
6.6.5 La ricerca binaria . . . . . . . . . . . . . . . . . . . . . . 174
6.6.6 Array parzialmente riempiti . . . . . . . . . . . . . . . . . 177
6.6.7 Array multidimensionali . . . . . . . . . . . . . . . . . . . 181
6.6.8 Esercizi su schemi di programmi . . . . . . . . . . . . . . 184
Capitolo 7
Un primo sguardo agli oggetti 187
7.1 Schema e valori . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
7.2 Elementi di classe e d’istanza . . . . . . . . . . . . . . . . . . . . 188
7.3 Dichiarazione di classi . . . . . . . . . . . . . . . . . . . . . . . . 191
7.4 Creazione di oggetti . . . . . . . . . . . . . . . . . . . . . . . . . 192
7.5 Distruzione di oggetti . . . . . . . . . . . . . . . . . . . . . . . . 194
7.6 La classe Class e l’istanziazione dinamica . . . . . . . . . . . . . . 195
7.7 Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
Capitolo 8
I metodi 197
8.1 Dichiarazione e chiamata di metodi . . . . . . . . . . . . . . . . . 198
8.1.1 Cosa è un metodo? . . . . . . . . . . . . . . . . . . . . . . 198
8.1.2 La dichiarazione di metodo . . . . . . . . . . . . . . . . . 198
8.1.3 L’invocazione di metodi . . . . . . . . . . . . . . . . . . . 199
8.1.4 Il comando return . . . . . . . . . . . . . . . . . . . . . . 202
8.1.5 Il meccanismo di chiamata . . . . . . . . . . . . . . . . . 202
8.1.6 Un esempio con chiamanti e chiamati . . . . . . . . . . . . 204
8.2 I metodi variadici . . . . . . . . . . . . . . . . . . . . . . . . . . 208
8.3 I metodi sovraccarichi . . . . . . . . . . . . . . . . . . . . . . . . 210
8.3.1 L’overloading . . . . . . . . . . . . . . . . . . . . . . . . 210
8.3.2 Un esempio di overloading . . . . . . . . . . . . . . . . . 211
8.3.3 Le regole per la risoluzione . . . . . . . . . . . . . . . . . 212
8.4 I metodi generici . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
8.4.1 La dichiarazione di metodo generico . . . . . . . . . . . . 215
8.4.2 L’invocazione di metodo generico . . . . . . . . . . . . . . 217
8.4.3 Un esempio: da array a vettori . . . . . . . . . . . . . . . . 219
8.5 La ricorsione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
8.5.1 Un’introduzione alla ricorsione . . . . . . . . . . . . . . . 220
8.5.2 La definizione di ricorsione . . . . . . . . . . . . . . . . . 221
8.5.3 Ricorsione diretta, indiretta, multipla, mutua . . . . . . . . 222
8.5.4 L’implementazione della ricorsione . . . . . . . . . . . . . 224
8.6 Schemi di programmi ricorsivi . . . . . . . . . . . . . . . . . . . . 227
8.6.1 Calcolo di funzioni ricorsive . . . . . . . . . . . . . . . . . 227
8.6.2 La ricerca binaria . . . . . . . . . . . . . . . . . . . . . . 229
8.6.3 Operazioni su sequenze . . . . . . . . . . . . . . . . . . . 230
8.6.4 Operazioni su alberi . . . . . . . . . . . . . . . . . . . . . 232
8.7 Cosa può andare male? . . . . . . . . . . . . . . . . . . . . . . . . 234
8.8 Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
Capitolo 9
La programmazione orientata agli oggetti 245
9.1 La filosofia dell’object-oriented . . . . . . . . . . . . . . . . . . . 245
9.2 I quattro strumenti dell’object-oriented . . . . . . . . . . . . . . . 247
9.3 La programmazione object-oriented in Java . . . . . . . . . . . . . 251
9.3.1 Le classi in Java . . . . . . . . . . . . . . . . . . . . . . . 252
9.3.2 Gli oggetti in Java . . . . . . . . . . . . . . . . . . . . . . 253
9.3.3 I messaggi in Java . . . . . . . . . . . . . . . . . . . . . . 253
9.3.4 L’ereditarietà in Java . . . . . . . . . . . . . . . . . . . . . 254
9.3.5 L’astrazione in Java . . . . . . . . . . . . . . . . . . . . . 254
9.3.6 L’incapsulamento in Java . . . . . . . . . . . . . . . . . . 255
9.3.7 Il polimorfismo in Java . . . . . . . . . . . . . . . . . . . 257
9.4 Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
Capitolo 10
Sviluppo di classi 261
10.1 Dichiarazione di classi: l’intestazione . . . . . . . . . . . . . . . . 262
10.2 Il corpo di una classe . . . . . . . . . . . . . . . . . . . . . . . . . 263
10.2.1 I contesti statici e non statici, e la parola chiave this . . . . . 264
10.2.2 Le variabili di classe e d’istanza . . . . . . . . . . . . . . . 267
10.2.3 I costruttori e this() . . . . . . . . . . . . . . . . . . . . . 272
10.2.4 I blocchi di inizializzazione . . . . . . . . . . . . . . . . . 280
10.2.5 I metodi . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
10.2.6 Le tecniche di incapsulamento . . . . . . . . . . . . . . . . 285
10.3 Le classi annidate . . . . . . . . . . . . . . . . . . . . . . . . . . 296
10.3.1 Le classi membro . . . . . . . . . . . . . . . . . . . . . . 297
10.3.2 Le classi locali e anonime . . . . . . . . . . . . . . . . . . 303
10.4 Compilazione e esecuzione di classi . . . . . . . . . . . . . . . . . 305
10.4.1 Unità di compilazione . . . . . . . . . . . . . . . . . . . . 306
10.4.2 Il caricamento di una classe . . . . . . . . . . . . . . . . . 307
10.4.3 La creazione di istanze . . . . . . . . . . . . . . . . . . . . 309
10.5 Cosa può andare male? . . . . . . . . . . . . . . . . . . . . . . . . 311
10.6 Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
Capitolo 11
Ereditarietà e interfacce 317
11.1 Sottoclassi e superclassi . . . . . . . . . . . . . . . . . . . . . . . 318
11.1.1 Ereditarietà come inclusione e specializzazione . . . . . . . 320
11.1.2 Tipi riferimento a tempo di esecuzione: instanceof e cast . . 323
11.1.3 Sovrascrittura di metodi e binding dinamico . . . . . . . . . 327
11.1.4 Accesso a membri della superclasse con super . . . . . . . 332
11.1.5 Costruttori e costruzione di istanze in presenza di ereditarietà 334
11.1.6 La radice della gerarchia: la classe Object . . . . . . . . . . 337
11.1.7 Incapsulamento ed ereditarietà: il modificatore protected . . 339
11.2 Le classi astratte . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
11.2.1 Alcune note su metodi astratti e classi astratte . . . . . . . . 343
11.3 Le interfacce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
11.3.1 La dichiarazione di interfacce . . . . . . . . . . . . . . . . 344
11.3.2 Implementare le interfacce . . . . . . . . . . . . . . . . . . 347
11.3.3 I ruoli delle interfacce . . . . . . . . . . . . . . . . . . . . 349
11.4 I tipi generici e la gerarchia dei tipi . . . . . . . . . . . . . . . . . 357
11.4.1 I parametri di tipo semplici . . . . . . . . . . . . . . . . . 358
11.4.2 I parametri di tipo con un vincolo di supertipo . . . . . . . . 359
11.4.3 I parametri di tipo con più vincoli di supertipo . . . . . . . 360
11.4.4 I tipi wildcard e i vincoli extends e super . . . . . . . . . . 361
11.4.5 L’erasure e i raw type . . . . . . . . . . . . . . . . . . . . 363
11.5 Tipi enumerativi, di nuovo . . . . . . . . . . . . . . . . . . . . . . 364
11.5.1 Un esempio: la bilancia galattica e il metodo values() . . . . 365
11.5.2 Un esempio: la calcolatrice e i metodi propri . . . . . . . . 367
11.6 Le annotazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
11.6.1 Uso delle annotazioni . . . . . . . . . . . . . . . . . . . . 369
11.6.2 Le annotazioni predefinite . . . . . . . . . . . . . . . . . . 370
11.6.3 Definire e usare le proprie annotazioni . . . . . . . . . . . . 373
11.6.4 Recuperare le annotazioni e la Reflection API . . . . . . . . 376
11.7 Cosa può andare male? . . . . . . . . . . . . . . . . . . . . . . . . 377
11.8 Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
Capitolo 12
Eccezioni e tecniche di collaudo 383
12.1 Le situazioni anomale a tempo di esecuzione . . . . . . . . . . . . 384
12.1.1 L’accesso a posizioni inesistenti . . . . . . . . . . . . . . . 385
12.1.2 Gli errori di formato numerico . . . . . . . . . . . . . . . . 387
12.1.3 Gli errori aritmetici . . . . . . . . . . . . . . . . . . . . . 387
12.2 La gerarchia delle eccezioni . . . . . . . . . . . . . . . . . . . . . 388
12.3 Lanciare le eccezioni: il comando throw . . . . . . . . . . . . . . . 391
12.3.1 Creare le eccezioni . . . . . . . . . . . . . . . . . . . . . 393
12.4 Catturare le eccezioni: try, catch e finally . . . . . . . . . . . . . . 394
12.4.1 L’ispezione e la manipolazione di eccezioni . . . . . . . . . 400
12.5 Le eccezioni controllate e non controllate . . . . . . . . . . . . . . 402
12.5.1 La clausola throws . . . . . . . . . . . . . . . . . . . . . . 403
12.5.2 I controlli di analisi statica sulle eccezioni controllate . . . . 406
12.6 Definire le proprie eccezioni . . . . . . . . . . . . . . . . . . . . . 408
12.6.1 Un esempio: IllegalTimeException . . . . . . . . . . . . . 408
12.7 Il collaudo e il debug . . . . . . . . . . . . . . . . . . . . . . . . . 414
12.7.1 Alcune tecniche di collaudo . . . . . . . . . . . . . . . . . 416
12.7.2 Stack tracing e logging . . . . . . . . . . . . . . . . . . . 418
12.7.3 Le asserzioni . . . . . . . . . . . . . . . . . . . . . . . . . 424
12.7.4 Il debug in ambiente integrato . . . . . . . . . . . . . . . . 426
12.8 Come può andare peggio? . . . . . . . . . . . . . . . . . . . . . . 429
12.9 Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430
Capitolo 13
Multithreading 435
13.1 Il ciclo di vita di un thread . . . . . . . . . . . . . . . . . . . . . . 436
13.1.1 Gli stati di un thread . . . . . . . . . . . . . . . . . . . . . 436
13.1.2 Creare nuovi thread . . . . . . . . . . . . . . . . . . . . . 438
13.1.3 Controllare l’esecuzione . . . . . . . . . . . . . . . . . . . 439
13.1.4 Condizioni di terminazione . . . . . . . . . . . . . . . . . 441
13.2 Comunicazione e interazione fra thread . . . . . . . . . . . . . . . 441
13.2.1 Condivisione della memoria . . . . . . . . . . . . . . . . . 441
13.2.2 I monitor . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
13.2.3 Il comando synchronized . . . . . . . . . . . . . . . . . . 444
13.2.4 I metodi synchronized . . . . . . . . . . . . . . . . . . . . 446
13.2.5 wait() e notify() . . . . . . . . . . . . . . . . . . . . . . . 447
13.3 Cosa andrà male . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
13.4 Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452
Capitolo 14
Input e output 455
14.1 Gli stream . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455
14.1.1 Le operazioni su stream . . . . . . . . . . . . . . . . . . . 456
14.2 Input e output su file di testo . . . . . . . . . . . . . . . . . . . . . 465
14.2.1 Input e output di singoli caratteri su file di testo . . . . . . . 465
14.2.2 Input e output bufferizzati e formattati su file di testo . . . . 467
14.3 La serializzazione di oggetti . . . . . . . . . . . . . . . . . . . . . 473
14.3.1 Salvare gli oggetti su file . . . . . . . . . . . . . . . . . . 474
14.3.2 Leggere gli oggetti da file . . . . . . . . . . . . . . . . . . 475
14.3.3 Sviluppare classi che consentono la serializzazione . . . . . 477
14.4 I metodi della classe jbook.util.Input . . . . . . . . . . . . . . . . . 480
14.5 Cosa può andare male? . . . . . . . . . . . . . . . . . . . . . . . . 481
14.6 Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485
Capitolo 15
Accesso alla rete 487
15.1 Indirizzi di rete e la classe InetAddress . . . . . . . . . . . . . . . 487
15.2 Comunicazioni affidabili: TCP . . . . . . . . . . . . . . . . . . . . 490
15.2.1 I socket . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
15.2.2 Programmazione di un client . . . . . . . . . . . . . . . . 492
15.2.3 Programmazione di un server . . . . . . . . . . . . . . . . 495
15.3 Comunicazioni non affidabili: UDP . . . . . . . . . . . . . . . . . 500
15.3.1 Comunicazione via Datagram . . . . . . . . . . . . . . . . 500
15.3.2 Mittente UDP . . . . . . . . . . . . . . . . . . . . . . . . 501
15.3.3 Destinatario UDP . . . . . . . . . . . . . . . . . . . . . . 501
15.4 Cosa può andare male? . . . . . . . . . . . . . . . . . . . . . . . . 502
15.5 Esercizi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504
Appendice A
Grammatica di Java 505
A.1 Produzioni della grammatica lessicale di Java . . . . . . . . . . . . 505
A.2 Produzioni della grammatica sintattica di Java . . . . . . . . . . . . 506
Appendice B
Rappresentazione binaria di dati numerici 511
B.1 Rappresentazione binaria di valori senza segno . . . . . . . . . . . 511
B.2 Rappresentazione binaria di valori interi . . . . . . . . . . . . . . . 514
B.3 Rappresentazione binaria di valori con cifre decimali . . . . . . . . 516
Appendice C
Codice ASCII 517
Appendice D
Documentazione del codice con javadoc 519
D.1 I commenti javadoc . . . . . . . . . . . . . . . . . . . . . . . . . 520
D.2 Eseguire javadoc . . . . . . . . . . . . . . . . . . . . . . . . . . . 522
Indice analitico 525
