Lezioni di programmazione orientata agli oggetti in Java con elementi di strutture di dati e architettura dei calcolatori Copertina flessibile PDF
Preview Lezioni di programmazione orientata agli oggetti in Java con elementi di strutture di dati e architettura dei calcolatori Copertina flessibile
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
Description:The list of books you might like
