Giuseppe Callegarin
Java, Oggetti e Strutture Dati
Cedam 2004
www.javaOSD.org
INDICE
CAP. 1 Macchine, linguaggi e comunicazioni ..................................................... 1
1.1 Dai grandi elaboratori all’era dei dispositivi programmabili e comunicanti......... 1
1.2 Ostacoli alla comunicazione e possibili soluzioni .................................................... 3
Piattaforme e portabilità ............................................................................................... 3
Interfacciamento con l'utente........................................................................................ 4
La torre di Babele dei linguaggi di programmazione ..................................................... 5
Distribuzione e protocolli ............................................................................................. 6
Sicurezza ..................................................................................................................... 7
Il concetto di interoperabilità........................................................................................ 7
La comunicazione di documenti e XML ....................................................................... 8
I Servizi Web ............................................................................................................. 10
Modellare con UML................................................................................................... 11
1.3 Macchine e linguaggi ............................................................................................. 12
Macchine astratte e concrete ...................................................................................... 13
Interpretazione........................................................................................................... 13
Compilazione ............................................................................................................. 14
Macchine virtuali........................................................................................................ 15
Linguaggi intermedi (bytecode) .................................................................................. 16
1.4 La programmazione ad oggetti.............................................................................. 18
Origini e motivazioni della OOP ................................................................................. 18
Terminologia essenziale sugli oggetti.......................................................................... 19
Creazione ed uso di oggetti ........................................................................................ 22
Classi clienti e messaggi ............................................................................................. 22
Messaggi e diagrammi di sequenza ............................................................................. 23
Metodi che modificano e metodi che osservano .......................................................... 24
Information hiding e astrazione................................................................................... 25
Ereditarietà ................................................................................................................ 26
Overriding (ridefinizione) di metodi............................................................................ 28
Ereditarietà multipla ................................................................................................... 29
Polimorfismo.............................................................................................................. 30
Classi e metodi astratti ............................................................................................... 31
Interfacce................................................................................................................... 33
ESERCIZI §1.4 ............................................................................................................ 34
1.5 Il fenomeno Java .................................................................................................... 36
La genesi di Java ........................................................................................................ 36
Caratteristiche di Java ................................................................................................ 36
viii
Indice
Edizioni e versioni di Java .......................................................................................... 37
Primi esempi di Java................................................................................................... 38
1.6 Strutture dati, algoritmi e oggetti.......................................................................... 40
COMPLEMENTI al Cap. 1 ....................................................................................... 42
C1.1 Sviluppare ed eseguire programmi Java ............................................................ 42
C1.2 La proposta alternativa della Microsoft (dot net).............................................. 46
TEST DI AUTOVERIFICA ........................................................................................ 48
CAP. 2 Introduzione a Java............................................................................... 49
2.1 Preliminari, tipi, espressioni e riferimenti............................................................. 50
"Hello" e commenti .................................................................................................... 50
Blocchi e istruzioni..................................................................................................... 52
Regola del punto e virgola.......................................................................................... 52
Scrittura a video ed espressioni .................................................................................. 53
Letterali e UNICODE ................................................................................................ 54
Lettura dei parametri della linea comando................................................................... 54
Prime eccezioni .......................................................................................................... 55
Regole per gli identificatori ........................................................................................ 55
Variabili e assegnamento ............................................................................................ 56
Durata e campo d'azione delle variabili locali.............................................................. 58
Costanti simboliche .................................................................................................... 60
Tipi riferimento e variabili riferimento......................................................................... 60
Riferimento null ...................................................................................................... 62
"Hello" ad oggetti ...................................................................................................... 62
Effetti collaterali su oggetti ........................................................................................ 63
Uso e significato della variabile this ......................................................................... 64
Classificazione dei tipi di Java..................................................................................... 65
Comandi ed espressioni .............................................................................................. 66
Tipi primitivi e classe Math ........................................................................................ 67
I tipi integrali.............................................................................................................. 68
I tipi in virgola mobile ................................................................................................ 68
Sequenze di escape per i caratteri ............................................................................... 69
Operatori e precedenze............................................................................................... 70
Controllo forte dei tipi................................................................................................ 72
Casting e promozioni (conversioni di tipo) ................................................................. 72
Conversioni da stringa a numero e viceversa............................................................... 74
Problemi risolti........................................................................................................... 76
ESERCIZI §2.1 ............................................................................................................ 77
2.2 Metodi e attributi statici........................................................................................ 79
Metodi statici ............................................................................................................. 79
Attributi statici e inizializzatore statico ....................................................................... 81
ESERCIZI §2.2 ............................................................................................................ 82
2.3 Rudimenti di input/output .................................................................................... 83
Standard input e output .............................................................................................. 83
Lettura da tastiera e importazione di classi.................................................................. 84
ESERCIZI §2.3 ............................................................................................................ 86
2.4 Java funzionale....................................................................................................... 86
Definire funzioni statiche............................................................................................ 86
Firma di un metodo .................................................................................................... 87
Indice
ix
Funzioni ricorsive ed espressioni condizionali ............................................................. 87
Altri esempi di funzioni ricorsive ................................................................................ 89
ESERCIZI §2.4 ............................................................................................................ 91
2.5 Costrutti di controllo ............................................................................................. 92
Costrutto if .............................................................................................................. 92
Costrutto switch...................................................................................................... 96
Costrutto while ........................................................................................................ 97
Obblighi di inizializzazione ......................................................................................... 99
Costrutto for .......................................................................................................... 100
Costrutto do-while ............................................................................................... 102
Istruzioni break e continue nei cicli .................................................................... 103
ESERCIZI §2.5 .......................................................................................................... 104
2.6 Gli array ............................................................................................................... 105
Array monodimensionali e valori di default ............................................................... 105
Matrici ed array multidimensionali............................................................................ 108
Soluzione di problemi sugli array con uso di funzioni................................................ 110
ESERCIZI §2.6 .......................................................................................................... 113
2.7 Procedure e passaggio di parametri .................................................................... 114
Procedure (funzioni void ) ...................................................................................... 114
Ordinamento di un array........................................................................................... 116
Passaggio dei parametri............................................................................................ 117
Procedure ricorsive .................................................................................................. 119
ESERCIZI §2.7 .......................................................................................................... 123
2.8 Elaborazione di stringhe ...................................................................................... 123
Operazioni sulle stringhe .......................................................................................... 123
Confronto tra stringhe e tra oggetti .......................................................................... 124
Elaborazioni efficienti con StringBuffer e StringBuilder (Java 1.5) ........... 127
ESERCIZI §2.8 .......................................................................................................... 130
2.9 Oggetti immutabili............................................................................................... 130
Classi BigInteger e BigDecimal ....................................................................... 132
Definiamo la classe Razionale .............................................................................. 133
ESERCIZI §2.9 .......................................................................................................... 133
2.10 Ritardi, numeri casuali e grafica elementare .................................................... 135
Generazione di ritardi............................................................................................... 135
Generazione di numeri casuali .................................................................................. 136
Rudimenti di grafica elementare................................................................................ 138
Caricamento di immagini.......................................................................................... 142
ESERCIZI §2.10 ....................................................................................................... 144
2.11 Package utente e di piattaforma........................................................................ 145
I package ................................................................................................................. 145
Costruiamo dei package ........................................................................................... 145
I package di piattaforma........................................................................................... 148
ESERCIZI §2.11 ....................................................................................................... 150
2.12 Modificatori e visibilità...................................................................................... 150
Elenco dei modificatori............................................................................................. 150
Modificatori di accesso............................................................................................. 152
Assegnare la visibilità ad ogni entità ......................................................................... 153
Classi interne e classi anonime .................................................................................. 154
ESERCIZI §2.12 ....................................................................................................... 155
COMPLEMENTI al Cap. 2 ..................................................................................... 156
x
Indice
C2.1 Documentazione automatica con javadoc ...................................................... 156
C2.2 Espressioni regolari ........................................................................................... 162
TEST DI AUTOVERIFICA ...................................................................................... 164
CAP. 3 Approfondimenti su Java .................................................................... 165
3.1 Classi, tipi e involucri (box) ................................................................................. 165
Differenza tra classe e tipo ....................................................................................... 165
Sottotipi e supertipi.................................................................................................. 167
Il principio di sostituibilità ........................................................................................ 168
Regole sui tipi .......................................................................................................... 168
Upcasting/Downcasting............................................................................................ 169
Operatore instanceof .......................................................................................... 170
Le classi involucro (wrapper) ................................................................................... 171
Boxing/Unboxing ..................................................................................................... 172
Boxing/Unboxing impliciti (Java 1.5)........................................................................ 173
Tipi con ordinamento: l'interfaccia Comparable ..................................................... 174
ESERCIZI §3.1 .......................................................................................................... 176
3.2 Eccezioni e loro trattamento ................................................................................ 177
Cosa sono e come nascono le eccezioni.................................................................... 177
Leggere la "stack trace" ........................................................................................... 178
Trattare le eccezioni: un primo esperimento.............................................................. 179
Catena di rifiuti e conseguenze ................................................................................. 181
Costruire la robustezza............................................................................................. 181
Rifiuti e obblighi di trattamento (eccezioni controllate) ............................................. 182
Istruzione try-catch ............................................................................................ 184
Classe Throwable e classificazione delle eccezioni ................................................. 186
Istruzione throw ..................................................................................................... 187
Un esempio riassuntivo ............................................................................................ 187
ESERCIZI §3.2 .......................................................................................................... 189
3.3 Asserzioni (Java 1.4) ............................................................................................ 189
Cos'è un'asserzione ? ................................................................................................ 189
Simulare le asserzioni con le eccezioni...................................................................... 192
Verificare da programma l'abilitazione delle asserzioni.............................................. 193
ESERCIZI §3.3 .......................................................................................................... 194
3.4 Introduzione ai thread ......................................................................................... 194
Il concetto di thread ................................................................................................. 194
La creazione di thread .............................................................................................. 196
Sincronizzazione dei thread - Atomicità.................................................................... 199
Sincronizzazione su condizioni: wait e notify ...................................................... 204
Evoluzione degli stati di un thread ............................................................................ 207
Stallo e starvation..................................................................................................... 208
Esercizi §3.4 .............................................................................................................. 210
3.5 Array dinamici in Java: Vector ed ArrayList................................................ 210
La classe Vector .................................................................................................... 211
La classe ArrayList .............................................................................................. 213
3.6 La genericità (Java 1.5) ....................................................................................... 215
Il problema............................................................................................................... 215
La soluzione del problema: le classi generiche .......................................................... 216
Costruiamo una nostra classe generica...................................................................... 217
Indice
xi
Limitazioni sull'uso................................................................................................... 219
Il tipo grezzo di una classe generica.......................................................................... 219
Uso di più parametri ed espressioni di tipo "tipo"...................................................... 220
Genericità vincolata.................................................................................................. 220
Esercizi §3.6 ............................................................................................................... 222
3.7 Gli stream e la gestione dei file ............................................................................ 222
Il concetto di flusso .................................................................................................. 222
Concatenazione di flussi ........................................................................................... 224
Operazioni generali sui file ....................................................................................... 225
Creazione, scrittura e lettura di file testo................................................................... 226
Flussi di valori e di oggetti........................................................................................ 228
La gestione di file e cartelle ...................................................................................... 231
ESERCIZI §3.7 .......................................................................................................... 232
3.8 Uguaglianza e copia degli oggetti ..................................................................... 232
Ridefinire equals .................................................................................................. 233
Ridefinire e usare clone() per effettuare le copie .................................................. 235
Copie superficiali e copie profonde........................................................................... 237
ESERCIZI 3.8 ............................................................................................................ 239
3.9 Eventi e interfacce utente grafiche................................................................... 239
La programmazione guidata dagli eventi................................................................... 239
Gestione degli eventi con il modello di delegazione................................................... 240
Un primo esempio di ascolto .................................................................................... 242
Tipi di ascoltatori ..................................................................................................... 244
Gli adattatori............................................................................................................ 247
Componenti e contenitori ......................................................................................... 249
Componenti di testo ................................................................................................. 255
Gestione del Layout ................................................................................................. 257
Disegnare con il mouse............................................................................................. 259
Esercizi §3.9 ............................................................................................................... 261
3.10 Applet ................................................................................................................. 262
Cos'è una applet ? .................................................................................................... 262
Applet e sicurezza .................................................................................................... 263
Un'applet bottone e la console Java .......................................................................... 264
La lettura di parametri dalla pagina HTML............................................................... 266
Aprire pagine web da un'applet................................................................................. 268
Animazione con un'applet......................................................................................... 270
Visualizzazione di immagini...................................................................................... 272
ESERCIZI 3.10 .......................................................................................................... 274
COMPLEMENTI al Cap. 3. ..................................................................................... 274
C3.1 Garbage collection e finalize ........................................................................ 274
C3.2 Un esempio con le Swing................................................................................... 276
TEST DI AUTOVERIFICA ...................................................................................... 278
CAP.4 La progettazione ad oggetti.................................................................. 279
4.1 Oggetti, classi e relazioni tra classi ...................................................................... 279
Oggetti, astrazione e responsabilità........................................................................... 280
Stato di un oggetto - information hiding - metodi e attributi..................................... 281
Messaggi e classificazione dei metodi ....................................................................... 282
Il concetto di classe.................................................................................................. 283
Da UML a Java........................................................................................................ 285
xii
Indice
Creare gli oggetti: l'uso dei costruttori...................................................................... 286
Uso delle classi......................................................................................................... 287
La parola this e la memorizzazione degli oggetti................................................... 287
La relazione di dipendenza tra classi ......................................................................... 288
Evitare l'uso di oggetti globali (static) .................................................................. 289
La relazione di composizione.................................................................................... 291
La relazione di aggregazione .................................................................................... 291
La relazione di ereditarietà ....................................................................................... 293
Polimorfismo e collegamento ritardato ..................................................................... 296
La visibilità non può diminuire nelle sottoclassi......................................................... 296
Overloading e overriding .......................................................................................... 297
Metodi astratti e classi astratte ................................................................................. 298
Interfacce e relazione di implementazione................................................................. 301
La catena dei costruttori in Java ............................................................................... 305
Il costruttore di default e i codici hash ...................................................................... 306
Gli oggetti come stringhe: ridefinire toString ...................................................... 307
ESERCIZI §4.1 .......................................................................................................... 309
4.2 Progettiamo una piccola Virtual Machine .......................................................... 311
Le specifiche del problema ....................................................................................... 312
Analisi del problema................................................................................................. 314
Una proposta di soluzione ........................................................................................ 316
Il codice Java ........................................................................................................... 317
4.3 Il progetto per contratto ...................................................................................... 320
Specificare precondizioni.......................................................................................... 320
Specificare postcondizioni........................................................................................ 321
Il contratto ............................................................................................................... 322
Programmazione per contratto in Java 1.4 ................................................................ 323
ESERCIZI §4.3 .......................................................................................................... 326
4.4 Introduzione ai design pattern ............................................................................ 327
COMPLEMENTI al Cap. 4 ...................................................................................... 330
C4.1 Progettare interfacce grafiche per gli oggetti ................................................... 330
C4.2 Le classi come oggetti: una prova di riflessione ............................................... 334
TEST DI AUTOVERIFICA ...................................................................................... 336
CAP. 5 Introduzione alle strutture dati........................................................... 337
5.1 Liste concatenate.................................................................................................. 338
Liste astratte e concrete............................................................................................ 338
Nodi concatenabili.................................................................................................... 339
Costruzione di liste concatenate ............................................................................... 340
Visita iterativa di una lista concatenata ..................................................................... 342
Visita ricorsiva di una lista concatenata .................................................................... 343
Inserimento in "mezzo" o in coda ............................................................................. 344
Inserimento di un elemento in testa........................................................................... 346
Cancellazione di un elemento.................................................................................... 346
Nodi sentinella ......................................................................................................... 348
Liste circolari ........................................................................................................... 349
Liste doppiamente concatenate................................................................................. 349
Problemi risolti sulle liste concatenate....................................................................... 350
ESERCIZI §5.1 .......................................................................................................... 354
5.2 Pile ........................................................................................................................ 355
Indice
xiii
Il concetto di pila ..................................................................................................... 355
Implementazione a lista ............................................................................................ 356
Implementazione con un vettore............................................................................... 358
Un'applicazione delle pile: la valutazione di espressioni RPN .................................... 359
ESERCIZI §5.2 .......................................................................................................... 362
5.3 Iteratori ................................................................................................................ 362
Analisi del problema................................................................................................. 362
Il concetto................................................................................................................ 363
La soluzione del problema........................................................................................ 366
Attraversamenti multipli ........................................................................................... 368
Problemi degli iteratori............................................................................................. 369
Gli iteratori della libreria standard di Java ................................................................. 369
Gli iteratori impliciti e il " foreach" (Java 1.5).......................................................... 371
ESERCIZI §5.3 .......................................................................................................... 373
5.4 Code...................................................................................................................... 374
Il concetto di coda.................................................................................................... 374
Impleme7ntazione con le liste concatenate................................................................ 375
Implementazione per code limitate............................................................................ 377
Code doppie e classe LinkedList ......................................................................... 378
Code con priorità ..................................................................................................... 380
Esercizi §5.4 ............................................................................................................... 381
5.5 Alberi binari......................................................................................................... 381
Definizione di albero binario ..................................................................................... 381
Operazioni sugli alberi binari .................................................................................... 383
Visite degli alberi binari............................................................................................ 383
Gli alberi binari come oggetti.................................................................................... 385
Problemi risolti sugli alberi binari.............................................................................. 388
Visite iterative e iteratore per gli alberi binari............................................................ 393
ESERCIZI §5.5 .......................................................................................................... 397
5.6 Alberi binari di ricerca ........................................................................................ 398
Definizione di albero binario di ricerca...................................................................... 398
Ricerca negli ABR................................................................................................... 400
Inserimenti e cancellazioni in un ABR....................................................................... 400
Alberi binari di ricerca come oggetti ......................................................................... 402
Un iteratore per gli alberi binari di ricerca................................................................. 404
ESERCIZI §5.6 .......................................................................................................... 407
5.7 Alberi.................................................................................................................... 408
Definizione di albero ................................................................................................ 408
Visite di un albero .................................................................................................... 410
La rappresentazione in memoria di alberi e foreste.................................................... 411
Rappresentare gli alberi con gli alberi binari: la rappresentazione naturale ................. 411
Gli alberi come oggetti ............................................................................................. 412
Iteratori per alberi .................................................................................................... 414
ESERCIZI §5.7 .......................................................................................................... 417
5.8 Grafi ..................................................................................................................... 418
Definizioni di grafo e terminologia............................................................................ 418
Rappresentazioni dei grafi ........................................................................................ 420
Visite (ricerche) in profondità e in larghezza sui grafi................................................ 422
I grafi come oggetti.................................................................................................. 423
Cammini minimi da un nodo (algoritmo di Dijkstra).................................................. 428
Esercizi §5.8 ............................................................................................................... 434
xiv
Indice
5.9 Strutture basate sulla trasformazione hash......................................................... 435
Dizionari o mappe .................................................................................................... 436
La trasformazione hash............................................................................................. 436
Collisioni.................................................................................................................. 437
Risoluzione delle collisioni ....................................................................................... 440
Prestazioni e limiti delle tabelle hash ......................................................................... 442
Tabelle e insiemi hash di Java ................................................................................... 443
ESERCIZI §5.9 .......................................................................................................... 445
COMPLEMENTI al Cap. 5 ...................................................................................... 445
C5.1 Notazione O-grande e complessità computazionale ......................................... 445
C5.2 Introduzione al Collections Framework di Java 1.5 ........................................ 449
TEST DI AUTOVERIFICA ...................................................................................... 451
Idee per progetti............................................................................................... 452
Appendice A.1. Installazione dei package di javaOSD ................................... 453
Appendice A.2 ndice delle tabelle su Java....................................................... 455
Bibliografia essenziale...................................................................................... 456
Sitografia essenziale ......................................................................................... 456
Indice analitico ................................................................................................. 457
