Sommario - Apogeonline

Sommario
PREFAZIONE ..................................................................................................... IX
Il nostro approccio didattico ............................................................................................. ix
Software incluso con questo libro .................................................................................... xii
Una panoramica del libro ............................................................................................... xiii
Ringraziamenti ................................................................................................................ xv
Gli autori ....................................................................................................................... xvii
Deitel & Associates, Inc. .............................................................................................. xviii
CAPITOLO 1: INTRODUZIONE AI COMPUTER, A INTERNET E AL WEB .......................... 1
1.1
1.2
1.3
1.4
1.5
1.6
1.7
1.8
1.9
1.10
1.11
1.12
1.13
1.14
1.15
Introduzione .......................................................................................................... 1
Che cos’è un computer? ......................................................................................... 3
La struttura del computer ...................................................................................... 3
L’evoluzione dei sistemi operativi .......................................................................... 4
I personal computer, i sistemi distribuiti e i sistemi client/server ........................... 5
I linguaggi macchina, assembly e di alto livello ...................................................... 5
La storia del linguaggio C++ .................................................................................. 7
La storia di Java ..................................................................................................... 8
Le librerie di classi Java .......................................................................................... 8
FORTRAN, COBOL, Pascal e Ada ...................................................................... 9
BASIC, Visual Basic, Visual C++, C# e .NET ..................................................... 10
Internet e il World Wide Web ............................................................................ 11
Gli elementi fondamentali di un tipico ambiente Java ......................................... 12
Alcune considerazioni generali su Java e su questo libro ...................................... 15
Pensare a oggetti: introduzione alla tecnologia degli oggetti
e a Unified Modeling Language ........................................................................... 17
1.16 Scoprire i design pattern: introduzione ................................................................ 21
Esercizi di autovalutazione ............................................................................................... 23
Risposte agli esercizi di autovalutazione ........................................................................... 24
Esercizi ............................................................................................................................ 24
CAPITOLO 2: INTRODUZIONE ALLE APPLICAZIONI JAVA ........................................... 27
2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
2.9
Introduzione ........................................................................................................ 27
Il primo programma in Java: scrivere una riga di testo ......................................... 27
Modificare il nostro primo programma Java ........................................................ 34
Visualizzare il testo in una finestra di dialogo ...................................................... 36
Un’altra applicazione Java: somma di interi ......................................................... 40
La memoria ......................................................................................................... 46
Aritmetica ............................................................................................................ 47
Prendere decisioni: operatori di uguaglianza e relazionali .................................... 50
(Caso di studio facoltativo) Pensare a oggetti: esame del problema ...................... 57
IV
SOMMARIO
Esercizi di autovalutazione ............................................................................................... 61
Risposte agli esercizi di autovalutazione ........................................................................... 63
Esercizi ............................................................................................................................ 64
CAPITOLO 3: INTRODUZIONE ALLE APPLET JAVA .................................................... 69
3.1
3.2
3.3
3.4
3.5
3.6
3.7
Introduzione ........................................................................................................ 69
Applet dimostrative dal Java 2 Software Development Kit .................................. 70
Una semplice applet Java: disegnare una stringa .................................................. 76
Disegnare stringhe e linee .................................................................................... 84
Sommare numeri a virgola mobile ....................................................................... 86
Risorse riguardanti le applet disponibili sul Web ................................................. 93
(Caso di studio facoltativo) Pensare a oggetti:
identificare le classi nella specifica del problema .................................................. 94
Esercizi di autovalutazione ............................................................................................... 99
Risposte agli esercizi di autovalutazione ......................................................................... 100
Esercizi .......................................................................................................................... 100
CAPITOLO 4: LE ISTRUZIONI DI CONTROLLO: PARTE 1 ......................................... 103
4.1
4.2
4.3
4.4
4.5
4.6
4.7
4.8
Introduzione ...................................................................................................... 103
Algoritmi ........................................................................................................... 103
Pseudocodice ..................................................................................................... 104
Strutture di controllo ......................................................................................... 104
L’istruzione di selezione singola if ...................................................................... 107
L’istruzione di selezione if...else ......................................................................... 109
L’istruzione iterativa while ................................................................................. 113
Formulare algoritmi: caso di studio 1
(iterazione controllata da un contatore) ............................................................. 115
4.9
Formulare algoritmi con raffinamento top-down
per passi successivi: caso di studio 2
(iterazione controllata da un valore sentinella) ................................................... 119
4.10 Formulare algoritmi con raffinamento top-down
per passi successivi: caso di studio 3 (strutture di controllo annidate) ................ 128
4.11 Operatori di assegnamento composti ................................................................. 133
4.12 Operatori di incremento e decremento .............................................................. 133
4.13 Tipi primitivi ..................................................................................................... 136
4.14 (Caso di studio facoltativo) Pensare a oggetti:
identificare gli attributi delle classi ..................................................................... 138
Esercizi di autovalutazione ............................................................................................. 141
Risposte agli esercizi di autovalutazione ......................................................................... 142
Esercizi .......................................................................................................................... 143
CAPITOLO 5: LE ISTRUZIONI DI CONTROLLO: PARTE 2 ......................................... 151
5.1
5.2
5.3
5.4
5.5
Introduzione ...................................................................................................... 151
Fondamenti dell’iterazione controllata da un contatore ..................................... 151
L’istruzione iterativa for ..................................................................................... 153
Esempi di utilizzo dell’istruzione for .................................................................. 158
L’istruzione iterativa do...while .......................................................................... 163
SOMMARIO
V
5.6
5.7
5.8
5.9
5.10
5.11
L’istruzione di selezione multipla switch ............................................................ 166
Le istruzioni break e continue ............................................................................ 170
Istruzioni break e continue con etichetta ........................................................... 173
Operatori logici ................................................................................................. 176
La programmazione strutturata: riepilogo .......................................................... 182
(Caso di studio facoltativo) Pensare a oggetti:
identificare gli stati e le attività degli oggetti ...................................................... 187
Esercizi di autovalutazione ............................................................................................. 190
Risposte agli esercizi di autovalutazione ......................................................................... 191
Esercizi .......................................................................................................................... 193
CAPITOLO 6: I METODI ................................................................................... 199
6.1
6.2
6.3
6.4
6.5
6.6
6.7
6.8
6.9
6.10
6.11
6.12
6.13
6.14
6.15
Introduzione ...................................................................................................... 199
Moduli del programma in Java .......................................................................... 199
I metodi della classe Math ................................................................................. 201
Dichiarazioni di metodo .................................................................................... 203
Promozione degli argomenti .............................................................................. 210
I package di Java API ......................................................................................... 211
Generazione casuale di numeri .......................................................................... 213
Esempio: un gioco d’azzardo ............................................................................. 217
Visibilità delle dichiarazioni ............................................................................... 226
I metodi della classe JApplet .............................................................................. 229
I metodi sovraccarichi ........................................................................................ 231
La ricorsione ...................................................................................................... 233
Un esempio che usa la ricorsione: la serie di Fibonacci ...................................... 237
Ricorsione e iterazione ....................................................................................... 242
(Caso di studio facoltativo) Pensare a oggetti:
identificare le funzionalità delle classi ................................................................ 244
Esercizi di autovalutazione ............................................................................................. 247
Risposte agli esercizi di autovalutazione ......................................................................... 249
Esercizi .......................................................................................................................... 253
CAPITOLO 7: GLI ARRAY .................................................................................. 263
7.1
Introduzione ...................................................................................................... 263
7.2
Gli array ............................................................................................................ 263
7.3
Dichiarare e creare array .................................................................................... 265
7.4
Esempi che usano array ..................................................................................... 266
7.5
Riferimenti e parametri riferimento ................................................................... 277
7.6
Passare gli array ai metodi .................................................................................. 278
7.7
Ordinare gli array .............................................................................................. 290
7.8
Ricerca negli array: ricerca lineare e ricerca binaria ............................................ 283
7.9
Array multidimensionali .................................................................................... 291
7.10 (Caso di studio facoltativo) Pensare a oggetti: la collaborazione tra oggetti ....... 298
Esercizi di autovalutazione ............................................................................................. 302
Risposte agli esercizi di autovalutazione ......................................................................... 303
Esercizi .......................................................................................................................... 303
Esercizi sulla ricorsione .................................................................................................. 314
Sezione speciale: costruite un vostro computer .............................................................. 317
VI
SOMMARIO
CAPITOLO 8: LA PROGRAMMAZIONE BASATA SU OGGETTI ...................................... 325
8.1
8.2
8.3
8.4
8.5
8.6
8.7
8.8
8.9
8.10
8.11
8.12
8.13
8.14
8.15
8.16
8.17
Introduzione ...................................................................................................... 325
Implementare un tipo di dato astratto “orario” con una classe .......................... 327
Visibilità di una classe ........................................................................................ 334
Il controllo dell’accesso ai membri di una classe ................................................ 335
Riferirsi ai membri dell’oggetto corrente con this .............................................. 336
Inizializzare gli oggetti di una classe: i costruttori .............................................. 338
Uso dei costruttori sovraccarichi ........................................................................ 339
Uso dei metodi set e get ..................................................................................... 344
La composizione ................................................................................................ 352
Garbage collection ............................................................................................. 356
Membri static di una classe ................................................................................ 356
Variabili di istanza final ..................................................................................... 361
Creazione di package ......................................................................................... 364
Accesso al package ............................................................................................. 369
Riusabilità del software ...................................................................................... 371
Astrazione dei dati e incapsulamento ................................................................. 372
(Caso di studio facoltativo) Pensare a oggetti:
iniziare a programmare le classi per il simulatore di ascensore ........................... 374
Esercizi di autovalutazione ............................................................................................. 377
Risposte agli esercizi di autovalutazione ......................................................................... 378
Esercizi .......................................................................................................................... 378
CAPITOLO 9: LA PROGRAMMAZIONE ORIENTATA AGLI OGGETTI: EREDITARIETÀ .......... 383
9.1
Introduzione ...................................................................................................... 383
9.2
Superclassi e sottoclassi ...................................................................................... 384
9.3
I membri protected ............................................................................................ 386
9.4
Relazioni tra superclassi e sottoclassi .................................................................. 387
9.5
Caso di studio: gerarchia di ereditarietà a tre livelli ............................................ 406
9.6
Costruttori e metodi finalize nelle sottoclassi ..................................................... 410
9.7
Ingegneria del software con l’ereditarietà ........................................................... 415
Esercizi di autovalutazione ............................................................................................. 416
Risposte agli esercizi di autovalutazione ......................................................................... 417
Esercizi .......................................................................................................................... 417
CAPITOLO 10: LA PROGRAMMAZIONE ORIENTATA AGLI OGGETTI: POLIMORFISMO ...... 419
10.1
10.2
10.3
10.4
10.5
10.6
Introduzione ...................................................................................................... 419
Relazioni tra oggetti in una gerarchia di ereditarietà .......................................... 420
10.2.1
Invocare metodi di superclasse da oggetti di sottoclasse ..................... 421
10.2.2
Usare riferimenti a superclasse con variabili di tipo sottoclasse .......... 422
10.2.3
Chiamare metodi di sottoclasse usando variabili
di tipo superclasse .............................................................................. 424
Esempi di polimorfismo .................................................................................... 426
Metodi e classi astratti ....................................................................................... 427
Caso di studio: ereditare l’interfaccia e l’implementazione ................................. 429
Classi e metodi final .......................................................................................... 438
SOMMARIO
VII
10.7
10.8
10.9
10.10
10.11
Caso di studio: un sistema di pagamento che usa il polimorfismo ..................... 439
Caso di studio: creare e usare le interfacce ......................................................... 449
Classi annidate................................................................................................... 454
Classi type-wrapper per tipi primitivi ................................................................ 468
(Caso di studio facoltativo) Pensare a oggetti:
incorporare l’ereditarietà nel simulatore di ascensore ......................................... 468
10.12 (Facoltativo) Scoprire i design pattern: introduzione ai design pattern
di creazione, strutturali e comportamentali ........................................................ 475
10.12.1 Design pattern di creazione ............................................................... 475
10.12.2 Design pattern strutturali .................................................................. 478
10.12.3 Design pattern comportamentali ....................................................... 479
10.12.4 Conclusione ...................................................................................... 481
Esercizi di autovalutazione ............................................................................................. 481
Risposte agli esercizi di autovalutazione ......................................................................... 481
Esercizi .......................................................................................................................... 481
CAPITOLO 11: I COSTRUTTORI DELLA CLASSE STRING ........................................... 485
11.1 Introduzione ......................................................................................................... 485
11.2 Concetti fondamentali dei caratteri e delle stringhe ........................................... 485
11.3 La classe String .................................................................................................. 486
11.3.1
I costruttori String ............................................................................ 486
11.3.2
I metodi length, charAt e getChars della classe String ....................... 488
11.3.3
Confrontare degli oggetti String ........................................................ 490
11.3.4
Localizzare caratteri e sottostringhe in stringhe ................................. 494
11.3.5
Estrarre sottostringhe da stringhe ...................................................... 497
11.3.6
Concatenare stringhe ......................................................................... 498
11.3.7
Altri metodi della classe String .......................................................... 499
11.3.8
Il metodo valueOf della classe String ................................................. 501
11.4 La classe StringBuffer ........................................................................................ 502
11.4.1
I costruttori di StringBuffer ............................................................... 503
11.4.2
I metodi di StringBuffer length, capacity, setLength
e ensureCapacity ............................................................................... 504
11.4.3
I metodi di StringBuffer charAt, setCharAt, getChars e reverse ......... 505
11.4.4
Il metodo append di StringBuffer ...................................................... 507
11.4.5
I metodi di inserzione e cancellazione di StringBuffer ....................... 509
11.5 La classe Character ............................................................................................ 510
11.6 Classe StringTokenizer ...................................................................................... 517
11.7 Un programma che mescola e distribuisce delle carte da gioco .......................... 519
11.8 Le espressioni regolari e le classi Pattern e Matcher ........................................... 524
11.9 (Caso di studio facoltativo) Pensare a oggetti: la gestione degli eventi ............... 534
Esercizi di autovalutazione ............................................................................................. 540
Risposte agli esercizi di autovalutazione ......................................................................... 541
Esercizi .......................................................................................................................... 541
Sezione speciale: esercizi avanzati di manipolazione delle stringhe ................................. 543
Sezione speciale: progetti difficili di manipolazione di stringhe ..................................... 546
VIII
SOMMARIO
APPENDICE A: PRIORITÀ E ASSOCIATIVITÀ DEGLI OPERATORI ................................... 547
APPENDICE B: I CARATTERI ASCII .................................................................... 549
APPENDICE C: I SISTEMI NUMERICI .................................................................... 551
C.1
Introduzione ...................................................................................................... 551
C.2
L’abbreviazione dei numeri binari in numeri ottali ed esadecimali .................... 554
C.3
La conversione di numeri ottali ed esadecimali in numeri binari ....................... 556
C.4
La conversione da binario, ottale o esadecimale in decimale .............................. 556
C.5
La conversione da decimale a binario, ottale o esadecimale ............................... 557
C.6
I numeri binari negativi: la notazione con complemento a due ......................... 558
Esercizi di autovalutazione ............................................................................................. 560
Risposte agli esercizi di autovalutazione ......................................................................... 560
Esercizi .......................................................................................................................... 562
APPENDICE D: UNICODE ................................................................................ 563
D.1 Introduzione ...................................................................................................... 563
D.2 I formati di trasformazione di Unicode ............................................................. 564
D.3 Caratteri e glifi................................................................................................... 565
D.4 Vantaggi e svantaggi di Unicode........................................................................ 565
D.5 Uso di Unicode ................................................................................................. 566
D.6 Intervalli di caratteri .......................................................................................... 568
Esercizi di autovalutazione ............................................................................................. 569
Risposte agli esercizi di autovalutazione ......................................................................... 569
Esercizi .......................................................................................................................... 570
BIBLIOGRAFIA ................................................................................................. 571