Lezioni di programmazione orientata agli oggetti in Java con elementi di strutture di dati e architettura dei calcolatori Copertina flessibile

252 Pages·2014·16.93 MB·Italian

by  Christian Nigro

Christian Nigro, Libero Nigro
Lezioni di
P O
rogrammazione rientata
O J
agli ggetti in ava
con elementi di strutture di dati
e architettura dei calcolatori
S
Pitagora Editrice Bologna
Premessa ______ ______
Questo testo raccoglie gran parte delle lezioni del corso di Programmazione Orientata agli Oggetti (POO) che
Libero Nigro svolge da diversi anni presso il corso di laurea in Ingegneria Informatica dell’Llniversità della
Calabria. Le lezioni assumono che l’allievo abbia già seguito un primo corso di Fondamenti di Informatica e
dunque abbia già familiarizzato con i concetti fondamentali di algoritmo, calcolatore e risoluzione algoritmica di
problemi secondo lo stile procedurale. I primi due capitoli del testo, comunque, richiamano gli argomenti di
base della programmazione procedurale in Java, cioè i tipi primitivi, le strutture di controllo e la gestione di
strutture dati array unitamente allo sviluppo di diversi programmi dimostrativi. Dal terzo capitolo in poi si
approfondisce la programmazione orientata agli oggetti in Java e la messa a punto di classi ‘tagliate su
misura" delle applicazioni, organizzate in biblioteche di moduli riutilizzabili, robuste rispetto al verificarsi di
eccezioni, ed eventualmente dotate di interfaccia grafica di interazione (GUI). Lo studio della POO include i
meccanismi di programmazione mediante tipi generici, e approfondisce classi proprie della libreria di Java ed
in particolare il collection framework (liste, set e mappe) considerato il suo ruolo strategico ai fini delle
applicazioni. Successivamente si forniscono elementi di conoscenza riguardanti l’implementazione di
collezioni custom lineari (liste concatenate) e non lineari (alberi e grafi), le tecniche di programmazione
ricorsiva, si introducono i concetti di complessità degli algoritmi, si presentano algoritmi efficienti di
ordinamento, si discutono alcune strutture di dati e le nozioni dello unit testing. I meccanismi della POO
vengono messi in pratica attraverso il progetto e lo sviluppo di applicazioni non banali. In particolare, si mostra
una realizzazione ad oggetti di un sistema software che emula un calcolatore didattico (RASP) utilizzato per la
programmazione in assembler, ed una libreria di classi a supporto di programmi basati sui grafi. Un capitolo a
parte è dedicato ad un’introduzione alla programmazione multi-thread e al progetto di classi thread-safe, con
diversi esempi di programmi concorrenti. Chiudono il testo due appendici nelle quali rispettivamente vengono
studiati (a) la rappresentazione in bit delle informazioni, (b) il calcolatore didattico RASP.
Il testo si caratterizza per uno stile di presentazione “essenziale” ma rigoroso, e per la “prevalenza del codice",
ossia la scrittura dettagliata di programmi completi sui vari argomenti affrontati.
Si ritiene che il testo possa essere utile nel biennio di Ingegneria Informatica o dei corsi di studio in
Informatica.
Si ringraziano i colleghi ed amici Franco Cicirelli, Angelo Furfaro e Francesco Pupo per le utili discussioni su
molte parti del testo, che hanno consentito di migliorare la presentazione e rimuovere errori. Gli autori saranno
grati a quanti vorranno segnalare ogni altro errore inevitabilmente rimasto, inviando una email all’indirizzo
[email protected].
ISBN 88-371 -1893-7
co Copyright 2014 by Pitagora Editrice s.r.l., Via del Legatore 3, 40138 Bologna, Italy.
Tutti i diritti sono riservati, nessuna parte di questa pubblicazione può essere riprodotta, memorizzata o trasmessa per
mezzo elettronico, elettrostatico, fotocopia, ciclostile, senza il permesso dell'Editore.
Stampa: Pitagora Editrice s.r.l., Via del Legatore 3,40138 Bologna, Italy.
Codice: 49/19
http://www.pitagoragroup.it
e-mail: [email protected]
Indice ______
Capitolo 1 :...............................................................................................................................................................1
Concetti di programmazione procedurale in Java..................................................................................................1
Un primo programma:....................................................................................................................................1
Formato dell'output:.......................................................................................................................................3
Tipi di base.........................................................................................................................................................3
Conversioni di tipo e casting..............................................................................................................................4
Incremento/decremento e assegnamento con aritmetica.................................................................................4
Algebra di Boole.................................................................................................................................................5
Proprietà dell’algebra di Boole...........................................................................................................................5
Operatori booleani e corto circuito....................................................................................................................6
La classe Math....................................................................................................................................................7
Classe Scanner (Java 5 o versione superiore).................................................................................................7
Il metodo printf di System.out (Java 5 o versione superiore)...........................................................................8
Espressioni e assegnazione...............................................................................................................................8
Strutture di controllo...........................................................................................................................................8
Selezione a due vie (if-else)...............................................................................................................................9
Un esempio di programma:............................................................................................................................9
Compilazione/esecuzione del programma:.....................................................................................................9
Ciclo di while (o a condizione iniziale).............................................................................................................10
Ciclo di while a condizione finale......................................................................................................................10
If-implicito (operatore ?)....................................................................................................................................11
Selezione n-aria (switch) Analisi dei casi possibili..........................................................................................11
Istruzione for.....................................................................................................................................................11
Un programma per il calcolo della potenza an.................................................................................................12
Un programma per l'equazione di secondo grado..........................................................................................13
Massimo comun divisore ed algoritmo di Euclide............................................................................................13
Somma dei primi N numeri naturali..................................................................................................................14
Equivalenza di Gauss.......................................................................................................................................14
Calcolo del fattoriale.........................................................................................................................................14
Calcolo del mcm...............................................................................................................................................15
Calcolo del fattoriale affidato ad un metodo.....................................................................................................15
Un metodo potenza..........................................................................................................................................16
Un secondo metodo potenza...........................................................................................................................16
Un terzo metodo potenza.................................................................................................................................17
Un metodo che verifica se un intero positivo è primo......................................................................................17
Metodo di Newton per il calcolo della radice quadrata di un numero reale....................................................17
Sviluppo di un programma................................................................................................................................18
Programma Lotto:........................................................................................................................................18
Caso di studio: sviluppo di un programma Calendario per passi successivi..................................................20
Versione di massima del programma:...........................................................................................................20
Programma completo:..................................................................................................................................22
Perfezionamenti:.........................................................................................................................................23
Strutturazione in metodi:..............................................................................................................................24
Un altro caso di studio: Sottosequenza di dimensione massima....................................................................25
Un primo algoritmo:......................................................................................................................................25
Un programma Java:...................................................................................................................................26
Nuova versione del programma:...................................................................................................................27
Esercizi.............................................................................................................................................................28
Capitolo 2:.............................................................................................................................................................29
Strutture dati array................................................................................................................................................29
Array monodimensionali o vettori....................................................................................................................29
i
Indice Indice
Caso di studio: mini-statistica sui voti di un campione di studenti..................................................................30 Altri esempi di passaggi di parametri..............................................................................................................76
Programma Statistica:..................................................................................................................................30 “Buon comportamento" sui parametri..............................................................................................................76
Calcolo della moda:.....................................................................................................................................31 Ancora sui costruttori di una classe.................................................................................................................77
Prodotto scalare di due vettori:...................................................................................................................35 Regole di visibilità dei nomi..............................................................................................................................77
Ricerca lineare:..........................................................................................................................................35 Classi e visibilità globale...................................................................................................................................78
Ricerca binaria:..........................................................................................................................................35
Argomenti variabili (vararg)..............................................................................................................................79
Un metodo per la ricerca binaria:.................................................................................................................36
System.out.printf e vararg................................................................................................................................79
Algoritmi di ordinamento...................................................................................................................................36
Enumerazioni....................................................................................................................................................79
Un metodo selectionSort:............................................................................................................................37
Concetto di bean...............................................................................................................................................80
Un metodo bubbleSort:...............................................................................................................................38
Esercizi.............................................................................................................................................................80
Un metodo insertionSort:............................................................................................................................39
Capitolo 4:.............................................................................................................................................................85
Triangolo di Tartaglia........................................................................................................................................39
Ereditarietà, dynamic binding e polimorfismo......................................................................................................85
Array bidimensionali e matrici..........................................................................................................................40
Una classe ContoBancario..............................................................................................................................85
Somma righe e colonne:.............................................................................................................................41
Richiami di algebra lineare..............................................................................................................................42 Un conto bancario con fido..............................................................................................................................86
Una classe ContoConFido erede di ContoBancario:......................................................................................86
Progetto di un programma...............................................................................................................................45
Il pronome super...............................................................................................................................................86
Programma Matrici:....................................................................................................................................45
Un’implementazione di ContoConFido con gestione dello “scoperto":............................................................86
Quadrato magico..............................................................................................................................................46
Relazione di ereditarietà...................................................................................................................................88
Array multi-dimensionali...................................................................................................................................46
Assegnazione tra oggetti come “proiezione"...................................................................................................88
Esercizi.............................................................................................................................................................47
Tipo statico e tipo dinamico di un oggetto.......................................................................................................89
Capitolo 3:............................................................................................................................................................49
Assegnazione dal generale al particolare ?....................................................................................................89
Classi e oggetti.....................................................................................................................................................49
Dynamic binding e polimorfismo.....................................................................................................................90
Una classe Punto............................................................................................................................................49
Ereditarietà e ridefinizione di metodi...............................................................................................................90
Variabili di istanza...........................................................................................................................................50
Ereditarietà singola...........................................................................................................................................91
Il pronome this................................................................................................................................................50
Ereditarietà vs. composizione.........................................................................................................................91
Oggetti e riferimenti........................................................................................................................................51
L’antenato “cosmico" Object............................................................................................................................91
La costante nuli...............................................................................................................................................52
Strutture dati eterogenee..................................................................................................................................92
Oggetti incapsulati..........................................................................................................................................53
Riassunto modificatori......................................................................................................................................92
Una classe Triangolo......................................................................................................................................54
Gestione casi “anomali" (preliminare)......................... 92
Overloading dei metodi...................................................................................................................................56
Una classe BancaArray (facade).....................................................................................................................93
Una classe Poligono.......................................................................................................................................56
Un altro esempio di gerarchia di classi...........................................................................................................94
Caso di studio: un programma genetico........................................................................................................57
Una classe Contatore:.................................................................................................................................94
Programma GiocoDellaVita:.......................................................................................................................58
Una classe ContatoreModulare specializzazione di Contatore:.......................................................................95
Una classe Razionale.....................................................................................................................................60
Ordine di esecuzione dei costruttori................................................................................................................96
Entità static.....................................................................................................................................................62
Gerarchie di classi e finalize.............................................................................................................................97
Entità di istanza ed entità di classe................................................................................................................63
Il metodo getClass() di Object.........................................................................................................................97
Progetto di classi di utilità...............................................................................................................................64
Caso di studio: Una classe Retta.....................................................................................................................98
Caso di studio: una classe Data.....................................................................................................................65
Esercizi...........................................................................................................................................................103
Esperimenti casuali........................................................................................................................................67
Capitolo 5:...........................................................................................................................................................105
Librerie di classi riutilizzabili e packaging.......................................................................................................68
Classi astratte e interfacce..................................................................................................................................105
Direttiva package............................................................................................................................................69
Una gerarchia di classi per figure geometriche piane....................................................................................105
La variabile di ambiente classpath.................................................................................................................70
Una classe astratta Figura:.........................................................................................................................105
Importazioni di classi......................................................................................................................................70
Una classe concreta Cerchio:.....................................................................................................................106
Compilazione/esecuzione di programmi in presenza di package.................................................................71
Una classe concreta Rettangolo:................................................................................................................106
Conflitti e risoluzione......................................................................................................................................72
Una classe astratta per il problema dell’ordinamento...................................................................................107
Libreria di Java...............................................................................................................................................72
Ordinare razionali...........................................................................................................................................109
Importazione statica (Java 5 o versioni superiori)..........................................................................................73
Limiti dell'approccio........................................................................................................................................110
Ambiente di sviluppo Eclipse (cenni)..............................................................................................................73
Il concetto di interfaccia..................................................................................................................................110
Passaggio di parametri ai metodi...................................................................................................................73
Razionali comparabili.....................................................................................................................................110
Cosa succede in Java ?.................................................................................................................................74
La classe di utilità Array di poo.util................................................................................................................111
Parametri attuali..............................................................................................................................................75
Ordinamento di razionali comparabili............................................................................................................111
Nozione di record di attivazione o trame........................................................................................................75
Discussione....................................................................................................................................................112
ii iii
Indice Indice
Regole di “buon progetto” di una classe Java................................................................................................112 I metodi salva/ripristina..............................................................................................................................154
Un altro esempio d’uso delle interfacce.........................................................................................................112 Un programma GestioneAgendina:.............................................................................................................155
L'interfaccia FiguraSolida:...........................................................................................................................114 Struttura dei comandi:................................................................................................................................155
Un’interfaccia come pacchetto di costanti......................................................................................................114 II metodo aggiungiNominativo:....................................................................................................................156
Esercizi...........................................................................................................................................................115 I metodi comandi ed errore:........................................................................................................................156
I metodi rimuoviNominativo e ricercaTelefono:............................................................................................156
Capitolo 6:...........................................................................................................................................................117
I metodi ricercaPersona e mostraElenco:.....................................................................................................157
Classi stringhe di caratteri...................................................................................................................................117
I metodi salva e carica:..............................................................................................................................157
Metodi di String di uso ricorrente....................................................................................................................117
II metodo quit:...........................................................................................................................................158
Esempio..........................................................................................................................................................119
Ancora sulle classi enum................................................................................................................................158
Proliferazione di stringhe garbage..................................................................................................................119
Esempio 1 : Una nuova classe Data...............................................................................................................159
Argomenti di un programma...........................................................................................................................120
Esempio 2: Un tipo enumerato Operazione..................................................................................................161
Classi StringBuffer e StringBuilder.................................................................................................................121
Enumerazioni e singleton...............................................................................................................................162
La classe StringTokenizer..............................................................................................................................123
Esercizi...........................................................................................................................................................162
Tokenizzazione mediante uno Scanner.........................................................................................................123
Altre letture.....................................................................................................................................................162
Caso di studio: valutazione di un’espressione aritmetica intera...................................................................124
Capitolo 9:...........................................................................................................................................................163
Esercizi...........................................................................................................................................................125
Collection framework e progetto di collezioni custom.......................................................................................163
Capitolo 7:...........................................................................................................................................................127
L’interfaccia Collection<T>.............................................................................................................................164
Concetti sulle eccezioni......................................................................................................................................127
L’interfaccia lterator<T>..................................................................................................................................165
Gerarchia di classi di eccezioni......................................................................................................................128
Schema d'uso di un iterator............................................................................................................................165
Vincoli sulle eccezioni checked......................................................................................................................130
Pattern tipico della remove.............................................................................................................................166
Il blocco try-catch............................................................................................................................................131
Metodi aggiunti dall’interfaccia List<T> che estende Collection<T>.............................................................166
Il blocco try-finally...........................................................................................................................................131
Metodi dell’interfaccia Listlterator<T> che estende lterator<T>...................................................................166
Flusso del controllo.........................................................................................................................................132
Un esempio di add() in ordine:....................................................................................................................167
Caso di studio: risoluzione di un sistema di equazioni lineari........................................................................133 Costruzione di una lista ordinata di stringhe mediante Listlterator:................................................................168
Una classe astratta Sistema:......................................................................................................................133 Classi ArrayList<T> e LinkedList<T>.............................................................................................................168
Il metodo di Gauss..........................................................................................................................................133
Concetti della lista concatenata semplice.....................................................................................................168
Una classe Gauss:.....................................................................................................................................134
Costruttori di ArrayList:..............................................................................................................................169
Una classe Sistemasingolare:....................................................................................................................135
Metodi propri di ArrayList<T>:.....................................................................................................................169
Un esempio di main:..................................................................................................................................136
Metodi propri di LinkedList<T>:...................................................................................................................169
Esercizi...........................................................................................................................................................136
Richiami su stack e coda................................................................................................................................170
Capitolo 8:...........................................................................................................................................................139 Esempio di gestione di uno stack:...............................................................................................................170
Tipi di dati astratti...............................................................................................................................................139 La classe di utilità Collections........................................................................................................................171
Un esempio di ADT......................................................................................................................................139 L’interfaccia Set<T>........................................................................................................................................171
L’ADT Vector:............................................................................................................................................139
Le classi HashSet<T> e TreeSet<T>.............................................................................................................171
Semantica delle operazioni............................................................................................................................139
Organizzazione di un albero binario di ricerca..............................................................................................171
Un’implementazione di Vector basata su array..............................................................................................140
Tabelle hash e collisioni.................................................................................................................................172
Un Vector generico e parametrico............................................................................................... 144
Operazioni insiemistiche.................................................................................................................................172
Classi wrapper dei tipi primitivi.......................................................................................................................145
Concetto di Map(pa........................................................................................................................................173
Boxing/unboxing automatico dei valori dei tipi primitivi..................................................................................146 L’interfaccia Map<K,V>:.............................................................................................................................173
Vector<T> generico e parametrico.................................................................................................................146 Le classi HashMap<K,V> e TreeMap<K,V>.................................................................................................174
L'interfaccia Vector<T>:..............................................................................................................................146
Riallocazione di una tabella hash...................................................................................................................174
La classe ArrayVector<T>:..........................................................................................................................147
L’interfaccia Comparatore^..........................................................................................................................174
Tipi “grezzi” e tipi generici...............................................................................................................................149
Un esempio d’uso di Comparator...................................................................................................................174
L’interfaccia Comparable generica:.............................................................................................................150
Estensione ed istanziazione al “volo".............................................................................................................175
Tabelle e loro rappresentazione.....................................................................................................................150
La classe di utilità Arrays................................................................................................................................175
Caso di studio: un programma per la gestione di un’agendina telefonica....................................................151
L’interfaccia lterable<T>.................................................................................................................................176
Una classe Nominativo:..............................................................................................................................151
Ciclo for-each..................................................................................................................................................176
Agendina come ADT:.................................................................................................................................152
Caso di studio: il Crivello di Eratostene..........................................................................................................177
Una classe AdendinaVector:.......................................................................................................................152
L'interfaccia Crivello e una classe astratta CrivelloAstratto:..........................................................................178
I metodi aggiungi/rimuovi:...........................................................................................................................153
Una classe CrivelloSet:..............................................................................................................................178
I metodi cerca:...........................................................................................................................................153
II metodo toString:......................................................................................................................................154 Vector<T> generico in versione iterabile........................................................................................................180
Le inner class..................................................................................................................................................181
IV
Indice Indice
For-each su oggetti Vector.............................................................................................................................181 La classe RandomAccessFile.......................................................................................................................217
Ancora sulle inner class..................................................................................................................................182 Ricerca binaria su un RandomAccessFile di interi ordinato:..........................................................................217
Progetto di collezioni custom..........................................................................................................................182 Insertion sort su un file di interi......................................................................................................................218
L'interfaccia Agendina con i commenti speciali per javadoc:.........................................................................183 Flussi testuali..................................................................................................................................................219
Una classe astratta AgendinaAstratta:.........................................................................................................185 Lettura di stringhe da tastiera........................................................................................................................220
Classi collezioni concrete...............................................................................................................................187 Costruttori di Scanner.....................................................................................................................................221
Una classe AgendinaMap:..........................................................................................................................187 PrintStream (es. System.out).........................................................................................................................221
Una classe AgendinaSet:............................................................................................................................188
Flussi di oggetti...............................................................................................................................................221
Una classe AgendinaLL:.............................................................................................................................188
Classi per flussi di oggetti:.........................................................................................................................222
Una classe AgendinaAL:................................................................................. 189
Salvataggio di un'agendina mediante serializzazione..................................................................................222
Osservazioni conclusive.................................................................................................................................190
serialVersionUID.............................................................................................................................................223
Classi storiche della piattaforma Java............................................................................................................190
Un esempio di applicazione della serializzazione/esternalizzazione............................................................224
Caso di studio: Crivello di Eratostone basato su BitSet.................................................................................191
Una classe BancaAstratta:.........................................................................................................................225
Esercizi...........................................................................................................................................................192 Classi ContoBancario e ContoConFido esternalizzate:................................................................................225
Altre letture.....................................................................................................................................................192 Tipi enumerati e serializzazione....................................................................................................................227
Capitolo 10:.........................................................................................................................................................193 Gestione di file e classe File..........................................................................................................................227
Tipi generici.........................................................................................................................................................193 Una classe ObjectFile con lettura anticipata.................................................................................................228
Generici e sotto tipi.........................................................................................................................................194 Caso di studio: fusione ordinata di file..........................................................................................................230
Wildcard..........................................................................................................................................................194 La classe MergeFile...................................................................................................................................231
Bounded wildcard...........................................................................................................................................195 Caso di studio: ordinamento esterno di file per fusione naturale..................................................................232
Classi con più tipi generici..............................................................................................................................195 La classe NaturalMergeSort.......................................................................................................................233
Metodi generici...............................................................................................................................................195 Esercizi...........................................................................................................................................................236
Il metodo generico Collections.max:............................................................................................................196 Altre letture.....................................................................................................................................................237
Type erasure...................................................................................................................................................197 Capitolo 13:.........................................................................................................................................................239
Restrizioni.......................................................................................................................................................197 Elementi di programmazione dell’interfaccia utente grafica..............................................................................239
Una classe Pair<T>:..................................................................................................................................198 Gerarchia base di finestre..............................................................................................................................239
Un metodo generico minMax:.....................................................................................................................198
Event delegation model..................................................................................................................................239
Un altro metodo generico minMax:.............................................................................................................199
Classificazione (parziale) degli eventi...........................................................................................................240
Eliminazione di parametri tipi.........................................................................................................................199
Gerarchia delle classi di eventi di AWT.........................................................................................................240
Regola Get/Put e wildcard..............................................................................................................................199
Interfacce di ascoltatori di eventi (Event Listener)........................................................................................241
Sotto tipi e covarianza....................................................................................................................................200
Adattatori (classi adapter)...............................................................................................................................242
Type erasure e metodi bridge........................................................................................................................201
Progetto di un ascoltatore...............................................................................................................................242
Wildcard capture.............................................................................................................................................203
Intercettazione e gestione dell’evento di chiusura:.......................................................................................243
Tipi generici e codice legacy..........................................................................................................................203
Sistema di coordinate.....................................................................................................................................244
Esercizi...........................................................................................................................................................205
Gerarchia di componenti GUI........................................................................................................................244
Altre letture.....................................................................................................................................................206
Inizializzazione di una JFrame......................................................................................................................244
Capitolo 11:.........................................................................................................................................................207
Uso di JFrame e JPanel.................................................................................................................................245
Ingresso/uscita grafico........................................................................................................................................207
Una finestra di cambio euro-lire....................................................................................................................247
Show confirm dialog.......................................................................................................................................208 Codice Java per la finestra di cambio:........................................................................................................247
Selezione di un file e classe JFileChooser....................................................................................................209 Una finestra con repainting.............................................................................................................................248
Esempio..........................................................................................................................................................211 Repainting e mouse:..................................................................................................................................250
Esercizi...........................................................................................................................................................211 Altri componenti di GUI...................................................................................................................................252
Capitolo 12:.........................................................................................................................................................213 JTextArea.................................................................................................................................................252
Flussi e file..........................................................................................................................................................213 JCheckBox................................................................................................................................................252
Classi base per i flussi binari.........................................................................................................................213 JRadioButton............................................................................................................................................252
Esempi di classi eredi concrete:..................................................................................................................213 JComboBox..............................................................................................................................................253
Copia di un file................................................................................................................................................214 JSlider.......................................................................................................................................................253
Crittografia elementare (cifrario di Giulio Cesare).........................................................................................214 JMenuBar, JMenu, JMenultem, JPopupMenu.............................................................................................253
Flussi bufferizzati............................................................................................................................................215 Un caso di studio - La classe AgendinaGUI.................................................................................................254
Le interface DataOutput e Datalnput.............................................................................................................215 La classe AgendinaGUI2................................................................................................................................256
Creazione di un file di interi............................................................................................................................215 Esercizi...........................................................................................................................................................256
Osservazioni...................................................................................................................................................216 Altre letture.....................................................................................................................................................256
vi vii
Indice Indice
Capitolo 14:.........................................................................................................................................................257 Esercizi...........................................................................................................................................................304
Introduzione alle espressioni regolari................................................................................................................257 Capitolo 18:.........................................................................................................................................................305
Esempi di regex..............................................................................................................................................257 Tecniche di programmazione ricorsiva..............................................................................................................305
Gruppi.............................................................................................................................................................258 Calcolo della potenza an.................................................................................................................................305
Espressione regolare di un numero realeJ ava..............................................................................................258 Analisi dell’esecuzione di potenza(2,3).........................................................................................................305
Il carattere punto 7.........................................................................................................................................259 Esercizio.........................................................................................................................................................306
Abbreviazioni..................................................................................................................................................259 Ricorsione in coda (tail recursion).................................................................................................................306
Le classi Pattern e Matcher del packagej ava.util.regex................................................................................259 Ricorsione e divide-et-impera........................................................................................................................307
Opzioni utili del metodo compile() di Pattern.................................................................................................260 Torri di Hanoi..................................................................................................................................................308
Caso di studio: un programma di patternm atching.......................................................................................260 Una soluzione Java:...................................................................................................................................308
Esercizi...........................................................................................................................................................261 Calcolo delle permutazioni.............................................................................................................................309
Altre letture.....................................................................................................................................................261 Problema delle N regine.................................................................................................................................310
Capitolo 15:.........................................................................................................................................................263 Una prima soluzione:.................................................................................................................................311
Una seconda soluzione:.............................................................................................................................312
Usta concatenata................................................................................................................................................263
Stack ed Heap................................................................................................................................................314
Gestione di una lista in Java.........................................................................................................................263
Conversione ricorsione-iterazione.................................................................................................................315
Il metodo inserisci)........................................................................................................................................266
Un metodo ricorsivo per l'ordinamento: Merge Sort.....................................................................................317
Il metodo rimuovi()..........................................................................................................................................268
Casi della rimozione:..................................................................................................................................268 Complessità di Merge Sort............................................................................................................................318
Costruttore di copia........................................................................................................................................268 Il metodo di ordinamento QuickSort..............................................................................................................320
Un metodo main()...........................................................................................................................................269 Esercizi...........................................................................................................................................................322
NulIPointerException......................................................................................................................................269 Capitolo 19:.........................................................................................................................................................323
Caso di studio: progetto di una collezioneo rdinata........................................................................................270 Strutture dati ricorsive e non lineari...................................................................................................................323
Una classe ListaOrdinataConcatenata<T>:..................................................................................................272 Lista concatenata e ricorsione.......................................................................................................................323
Stack ADT e gerarchia di classi....................................................................................................................274 Albero binario..................................................................................................................................................326
Una classe StackAstratto<T>.....................................................................................................................274 La classe AlberoBinarioDiRicerca<T>:........................................................................................................327
Una classe StackConcatenato<T>:.............................................................................................................276 Albero binario degli operatori di un’espressione aritmetica..........................................................................331
Una classe StackArray<T>:.......................................................................................................................277 Caso di studio.................................................................................................................................................332
Un’applicazione di test per lo stack:............................................................................................................279 Esempio di sessione:..........................................%....................................................................................335
Coda ADT e gerarchia di classi.....................................................................................................................280 PostOrder iterativo..........................................................................................................................................336
Una classe CodaAstratta<T>:.....................................................................................................................280 Alberi n-ari......................................................................................................................................................336
Una classe CodaConcatenata<T>:.............................................................................................................282 Grafi................................................................................................................................................................337
Una classe BufferLimitato<T>:....................................................................................................................283 Altri concetti e definizioni:..........................................................................................................................338
Un’applicazione di test per la coda:.............................................................................................................285 Rappresentazione in memoria di un grafo....................................................................................................338
Una classe ListaDoppia..................................................................................................................................287 Liste di adiacenze...........................................................................................................................................339
Esercizi...........................................................................................................................................................289 Il grafo come abstract data type: un esempio...............................................................................................339
Progetto..........................................................................................................................................................290 Operazioni di visita.........................................................................................................................................341
Capitolo 16:.........................................................................................................................................................293 Visita in ampiezza:.....................................................................................................................................341
Sviluppo di un’applicazione: aritmetica di polinomi...........................................................................................293 Visita in profondità:....................................................................................................................................341
Una classe Monomio:................................................................................................................................293 Raggiungibilità................................................................................................................................................342
Un’interfaccia Polinomio:...........................................................................................................................294 Esempio di grafo di raggiungibilità:.............................................................................................................342
Un diagramma di classi UML:....................................................................................................................295 Esercizi...........................................................................................................................................................343
La classe PolinomioLL:..............................................................................................................................297 Progetto..........................................................................................................................................................344
La classe PolinomioConcatenato:...............................................................................................................298
Capitolo 20:.........................................................................................................................................................345
Un programma di test:...............................................................................................................................299
Struttura dati Heap e HeapSort.........................................................................................................................345
Esercizi...........................................................................................................................................................300
Heap - definizione e proprietà......................................................................................................................345
Capitolo 17:.........................................................................................................................................................301
Aggiunta di un elemento.................................................................................................................................345
Concetti di complessità degli algoritmi................................................................................................................301
Rimozione del minimo....................................................................................................................................346
Complessità “esatta" di selection sort............................................................................................................301
Efficienza delle operazioni di inserimento/rimozione....................................................................................347
Notazione big O (ordine di) e comportamento asintotico per n->oo.............................................................302
Come sfruttare l’efficienza dell’heap ?..........................................................................................................348
Operatore Q. grande.......................................................................................................................................302
Possibili usi di una struttura dati heap...........................................................................................................348
Operatore © grande.......................................................................................................................................302 Complessità di Heap Sort...............................................................................................................................349
Alcune complessità.........................................................................................................................................303 Caso di studio: implementazione di una classe Heap..................................................................................349
vili IX
Indice Indice
La classe PriorityQueue<E> di java.util........................................................................................................351 Test di unità e JUnit........................................................................................................................................411
Costruttori:................................................................................................................................................351 JUnit 4.x....................................................................................................................................................411
Metodi:......................................................................................................................................................351 Esercizi...........................................................................................................................................................413
Esercizi...........................................................................................................................................................351 Altre letture.....................................................................................................................................................413
Capitolo 21:.........................................................................................................................................................353 Capitolo 23:.........................................................................................................................................................415
Sviluppo di programmi ad oggetti.......................................................................................................................353 Introduzione alla programmazione multi-thread................................................................................................415
Sommario della notazione UML sulle classi..................................................................................................353 Una prima applicazione multi-thread.............................................................................................................416
Relazioni (associazioni) tra classi e navigabilità:..........................................................................................354 Un generatore interrompibile.........................................................................................................................417
Relazioni e molteplicità:.............................................................................................................................354 Metodi della classe Thread............................................................................................................................418
Associazioni tutto/parti:..............................................................................................................................355 Merge sort multi-thread..................................................................................................................................419
Indice dei riferimenti incrociati in un testo.....................................................................................................355 Stazione di monitoraggio................................................................................................................................420
La classe GestoreTesto:............................................................................................................................356
Una stazione “naif”.........................................................................................................................................422
Tipo astratto Indice:...................................................................................................................................358
Una stazione thread-safe...............................................................................................................................423
La classe Parola:.......................................................................................................................................358
La classe Monitoraggio:.............................................................................................................................423
La classe IndiceAstratto:............................................................................................................................359
Mutua esclusione e sospensione...................................................................................................................424
La classe IndiceLinkato:.............................................................................................................................360
Cenni al Java Memory Model........................................................................................................................425
La classe IndiceMappato:..........................................................................................................................360
Una concretizzazione custom di IndiceAstratto:...........................................................................................361 Produttore/Consumatore e BufferLimitato.....................................................................................................425
L'applicazione Crosslndex:........................................................................................................................361 N Produttori M Consumatori..........................................................................................................................428
Un’implementazione della macchina RASP..................................................................................................362 Mailbox con risvegli FIFO..............................................................................................................................429
L’assemblatore a due passate:...................................................................................................................362 Mailbox con risvegli prioritari.........................................................................................................................430
Organizzazione del programma:.................................................................................................................363 Il problema dei cinque filosofi.........................................................................................................................432
Analizzatore lessicale (classe Lexer):.........................................................................................................364 Uso di blocchi synchronized...........................................................................................................................435
L’Assemblatore (classe Assembler):...........................................................................................................365 Scambiatore sincrono.....................................................................................................................................436
La classe ObjectModule:............................................................................................................................370 Classi Produttore e Consumatore...............................................................................................................437
La classe Simbolo:.....................................................................................................................................371 Esempio di output:.....................................................................................................................................438
La classe TabellaSimboli:..........................................................................................................................372 Thread e sistema delle eccezioni..................................................................................................................439
La classe JRVM:........................................................................................................................................372
Concorrenza e collection framework.............................................................................................................440
Una gerarchia di classi per la gestione dei grafi...........................................................................................376
La classe java.util. Vector<T>........................................................................................................................442
Il grafo come abstract data type:.................................................................................................................376
Concorrenza e oggetti immutabili..................................................................................................................442
La classe Arco<N>:....................................................................................................................................378
Variabili volatili................................................................................................................................................443
La classe ArcoPesato<N>:.........................................................................................................................378
Un esempio:..............................................................................................................................................443
La classe GrafoAstratto<N>:.......................................................................................................................379
Metodi di Atomiclnteger..................................................................................................................................444
L’interfaccia GrafoNonOrientato<N>:..........................................................................................................382
Buffer limitato con risvegli FIFO, basato su Lock/Condition.........................................................................445
La classe GrafoNonOrientatoAstratto<N>:...................................................................................................382
La classe GrafoNonOrientatolmpl<N>:.......................................................................................................383 Esercizi...........................................................................................................................................................447
L'interfaccia GrafoPesato<N>:....................................................................................................................385 Altre letture.....................................................................................................................................................448
L'interfaccia GrafoNonOrientatoPesato<N>:................................................................................................386 Appendice A:.......................................................................................................................................................449
La classe GrafoNonOrientatoPesatoAstratto<N>:........................................................................................386 Rappresentazione in bit delle informazioni........................................................................................................449
La classe GrafoNonOrientatoPesatolmpl<N>:.............................................................................................388 Sistemi di numerazione posizionali...............................................................................................................449
L'interfaccia GrafoOrientato<N>:................................................................................................................391 Sistemi ricorrenti:.......................................................................................................................................449
La classe astratta GrafoOrientatoAstratto<N>:............................................................................................391 Conversioni di base di numeri naturali..........................................................................................................449
La classe GrafoOrientatolmpl<N>:..............................................................................................................392
Conversione di una frazione decimale in una base B/10............................................................................451
L'interfaccia GrafoOrientatoPesato<N>:.....................................................................................................394
Codifica indiretta in bit....................................................................................................................................452
La classe astratta GrafoOrientatoPesatoAstratto<N>:..................................................................................394
Altri codici BCD...............................................................................................................................................453
La classe GrafoOrientatoPesatolmpl<N>:....................................................................................................396
Stringhe di bit di lunghezza n.........................................................................................................................453
La classe Peso:.........................................................................................................................................398
Aritmetica binaria............................................................................................................................................454
La classe Grafi del package poo.util:..........................................................................................................400
Rappresentazione dei numeri negativi..........................................................................................................455
Esercizi...........................................................................................................................................................403
Progetto..........................................................................................................................................................404 Rappresentazione per segno e modulo........................................................................................................455
Capitolo 22:.........................................................................................................................................................407 Rappresentazione per complementi diminuiti...............................................................................................455
Concetti di unit testing.........................................................................................................................................407 Rappresentazione per complementi alla base..............................................................................................455
Un metodo per rivelare i bit di un intero:.....................................................................................................457
L’istruzione asserì...........................................................................................................................................408
Operatori su interi a livello di bit....................................................................................................................458
Esempi:.....................................................................................................................................................408
Operatori di shift.............................................................................................................................................458
Caso di studio.................................................................................................................................................409
X XI
Indice
Sviluppo polinomiale e formula di Homer.....................................................................................................459
Formato Floating Point IEEE 754..................................................................................................................459 Capitolo _______________________________________________________________________
Casi particolari................................................................................................................................................460 Concetti di programmazione procedurale in Java
Numeri denormalizzati...................................................................................................................................461
Esercizi...........................................................................................................................................................461 Java è un moderno linguaggio orientato agli oggetti sviluppato dalla SUN Microsystems (oggi Oracle).
Appendice B:......................................................................................................................................................463 Supporta lo sviluppo di applicazioni per Internet (es. Applet) pur rimanendo un linguaggio per scopi generali. È
La macchina RASP.............................................................................................................................................463 portabile (praticamente) su tutte le piattaforme (Win, Solaris, Linux, MacOS, ...): "write once run anywhere".
Istruzioni di ingresso/uscita...........................................................................................................................465 Utilizza un approccio misto compilazione-interpretazione che è alla base della portabilità: il codice sorgente
Istruzioni di spostamento...............................................................................................................................465 Java è tradotto nel linguaggio, bytecode, di una macchina ipotetica (Java Virtual Machine o JVM)
Operazioni aritmetiche...................................................................................................................................465 normalmente implementata a software (CPU-interprete di bytecode) ma realizzabile anche in hardware.
Controllo del flusso di esecuzione.................................................................................................................466
Esempi di algoritmi RASP..............................................................................................................................466 È possibile programmare in Java mediante il "Java Development Kit" (JDK) o meglio lo "Standard
Rappresentazione in memoria di un programma..........................................................................................467 Development Kit" (SDK), attualmente nella versione 1.7 (Java 7). SDK è free e si può scaricare dal sito
Programma in linguaggio macchina numerico:............................................................................................469
http://iava.sun.com. Consiste di vari strumenti tra cui: javac (compilatore da Java a bytecode), java (interprete
Nomi simbolici e notazione Assembler..........................................................................................................469
del bytecode), javadoc, che genera informazioni HTML di documentazione. In Win SDK è utilizzabile "a riga di
Interpretazione di un programma in linguaggio macchina............................................................................470
comando" dall’interno di una finestra DOS (shell di sistema operativo).
Ciclo istruzione della CPU..............................................................................................................................471
Strumenti........................................................................................................................................................472
Java è un linguaggio ibrido: ammette tipi di base la cui gestione non è ad oggetti al fine di garantirne maggiore
Sintassi EBNF di Assembler RASP...............................................................................................................472
efficienza elaborativa (es. l'aritmetica tra numeri reali). Per il resto il linguaggio è orientato agli oggetti e
Esempi di programmi in Assembler RASP:...................................................................................................473
dunque estendibile mediante la programmazione di classi dipendenti dalle applicazioni.
Traduzione di un algoritmo Java in Assembler RASP..................................................................................474
Blocco:......................................................................................................................................................474
In questo capitolo si riassumono i concetti fondamentali sui tipi primitivi, le istruzioni di controllo e i metodi di
Assegnazione:..........................................................................................................................................475
Java e si mostrano esempi di programmi secondo lo stile procedurale. Si danno per acquisite dal corso di
Istruzione if:..............................................................................................................................................475
Istruzione if-else:........................................................................................................................................475 Fondamenti di Informatica le nozioni di calcolatore, memoria, algoritmo etc. Un programma sarà organizzato
Istruzione while:.........................................................................................................................................475 mediante una sola classe dotata del metodo main(), eventualmente supportato da ulteriori metodi static
Istruzione do-while:....................................................................................................................................476 appaiati col main e tra di loro (in Java come in C/C++ i metodi non si possono innestare aH'interno di altri
Istruzione for:............................................................................................................................................476 metodi), cui sono delegati sotto-compiti specifici. Per ragioni che saranno esposte nel cap. 3, tutti i metodi e le
Array di interi e accesso agli elementi:........................................................................................................476 variabili condivise tra i metodi di un programma procedurale devono essere dichiarate static. Un programma
Caso di studio.................................................................................................................................................476 procedurale Java corrisponde agevolmente ad un classico programma C: basta rimuovere i confini della
Istruzione di chiamata a metodo:................................................................................................................479 classe ed eliminare i modificatori static davanti ai metodi ed alle variabili condivise (se ce ne sono) che
Corpo di un metodo:..................................................................................................................................479 vengono cosi a costituire l’ambiente globale dell’applicazione.
Istruzione di ritorno da un metodo:..............................................................................................................479
Traduzione in assembler di un metodo ricorsivo...........................................................................................480
Convenzioni sui nomi: un nome di classe/interfaccia dovrebbe iniziare con una lettera maiuscola; un nome di
Traduzione in assembler di un metodo tail recursive....................................................................................483
metodo o variabile dovrebbe iniziare con una lettera minuscola; in un nome composto ogni iniziale di nome
Esercizi...........................................................................................................................................................485
(dal secondo in poi) dovrebbe essere maiuscola; un nome di costante dovrebbe essere tutto maiuscolo e se
composto, dovrebbe usare il carattere tra i diversi nomi componenti.
Un primo programma:
public class Cambio!
public static void main( String []args ){//contiene l’algoritmo da eseguire
final doublé CAMBIO_EURO. URE=1936.27; //costante reale
System.out.printlnf'Cambio lire in euro”); //scrittura sul video o standard output
//crea un oggetto Scanner, se, per la lettura da tastiera
Scanner sc=new Scanner( System.in ); //System.in è la tastiera o standard input
System.out.print("Lire=");
int lire=sc.nextlnt (); //legge da se il prossimo intero
doublé euro=lire/CAMBICLEURO .LIRE; //converte le lire in euro
System.out.println(lire+“ lire equivalgono a ”+euro+" euro");
}//main
}//Cambio
xii 1
Capitolo^ Concetti di programmazione procedurale
Operazioni di i/o:
In alternativa si può utilizzare un ambiente integrato di sviluppo che consente, tra l’altro, l’editing e le
Scrittura su video di una stringa: operazioni di compilazione e run dei programmi. Un esempio di strumento integrato di sviluppo in Java è
System.out.printlnfCambio lire in euro"); Eclipse, liberamente scaricabile dal sito http://www.Eclipse.org/downloads. Esso è stato sviluppato in gran
System.out.print("Lire=“); //emissione di prompt parte in Java. Mediante plug-in Eclipse può servire come ambiente di sviluppo anche per altri linguaggi, es.
C++. Un altro strumento è NetBeans sviluppato da Oracle/Java. NetBeans è realizzato interamente in Java
Effetto sul video della seconda stampa (print):
Formato dell’output:
Lire=_ Per lo stesso input precedente si ha ora:
Lire= 13500 INVIO
si scrive la stringa senza mandare a capo il cursore. import java.util. Scanner; 13500 lire equivalgono a 6.97 euro
public class Cambio{
Lettura da tastiera di un intero mediante scanner: public static void main( String [jargs ){ ossia la conversione in euro è visualizzata
int lire=sc.nextlnt(); //nextlnt è un metodo di Scanner (si veda più avanti in questo capitolo). final doublé cambioEuroLire= 1936.27; con due sole cifre frazionarie
System.out.println(’’Cambio lire in euro");
Osservazioni: Scanner sc=new Scanner( System.in ); Commenti
• Java è case-sensitive: alfa, Alfa, aLfa etc. sono nomi diversi. System. out.print("Lire="); //commento che risiede su una linea
• Non sono disponibili operazioni primitive di I/O nel linguaggio. Comandi di I/O sono comunque ottenibili int lire=sc.nextlnt (); r
utilizzando classi della libreria di Java come Scanner. doublé euro=lire/cambioEuroLire; commento che può svilupparsi su piu
• Le variabili sono dichiarabili ovunque in un blocco e possono ammettere inizializzazione. System.printf(“%1.2f%n", euro ); linee a piacimento
} 7
Variabili dichiarate ma non inizializzate: }//Cambio
int a, b, c; /**
commento speciale per javadoc
Variabili e inizializzazione: 7
int a, b=2, c;
Tipi di base
L’inizializzazione può essere realizzata successivamente con l'istruzione di assegnazione: Tipi interi-,
a=3; byte (da-128 a 127) 8 bit
short (da-32768 a 32767) 16 bit
Si nota (modello di memoria) che una variabile possiede un nome che riferisce una cella di memoria che int (da -2’ 147’483’648 a +2’ 147'483’647) 32 bit
contiene un valore (che può essere indefinito). Il valore può essere cambiato con un’istruzione di long ( omissis ) 64 bit
assegnazione (operatore ’=’). Un programma che faccia uso di variabili indefinite è erroneo.
Operatori: + - * / %
Stringhe e operazione di concatenazione: Gli operatori moltiplicativi (',/,%) hanno maggiore priorità di quelli additivi (+,-). Se necessario, si
possono utilizzare (sotto) espressioni entro parentesi ( ) che vengono valutate sempre prima.
"Una stringa" // una stringa è racchiusa tra una coppia di “
"Una stringa" + " più lunga" Esempi di letterali ed espressioni intere:
Passi di sviluppo a riga di comando: int x=y+5*z;
int x=(y+5)*z;
C:\MiaDioedit Cambio.java (o altro editor, es. notepad di Win) INVIO $
C:\MiaDir>javac Cambio.java INVIO 6 è un valore int
In assenza di errori, si genera il file Cambio.class (bytecode) 6L o 6I è un valore long
C:\MiaDir>java Cambio INVIO
Lancia l’interprete sul bytecode di Cambio.class int y=10%8; //assegna 2 ad y. % calcola il resto della divisione intera
y=i o/8; //assegna 1 ad y. / calcola il quoziente della divisione intera
Esempio di run (esecuzione):
Lire= 13500 INVIO
13500 lire equivalgono a 6.972132129650671 euro
2 3