Lezione del 01/06/2018: conclusione del corso!

Esercizio sulla ricorsione: calcolo dei cammini da un punto a un altro. Riassunto dei design pattern. Il pattern Callback. Consigli per il futuro. Conclusione del corso!

Lezione 30/05/2018: esercizi su ricorsione e design pattern

Controllo ricorsivo di una stringa palindroma. Il problema delle regine. Ricerca binaria ricorsiva. Esercizi sui design pattern: Configuration con singoletto e singoletti multipli; publisher/subscriber per eventi di bottoni; strategy per l'ordinamento di sequenze; builder eager e lazy su ListaDiInteri.

Lezione del 29/05/2018: i moduli (Java 9); decorator pattern; rassegna su input/output; serializzazione

I moduli di Java 9. Motivazioni, parole chiave module, exports, requires, requires transitive. Utilizzo di moduli pre-Java 9 mediante classpath (unnamed module) e come moduli automatici (nel module path).


Il Decorator Pattern: aggiungere responsabilità a una classe senza che essa lo sappia. L'esempio della rappresentazione grafica delle automobili.
 
Input & output: gli oggetti System.out e System.in. InputStream, PrintStream e la classe Scanner. File di testo e file binari. Gli stream. Gerarchie di classi stream. Leggere e scrivere un file di testo: la classe java.io.File. BufferedReader/FileReader, BufferedWriter/FileWriter. Leggere e scrivere un file di testo formattato: le classi Formatter e Scanner. Il package java.nio: Path, Paths e Files. Serializzare e deserializzare un oggetto. L'interfaccia Serializable. La parola chiave transient.

Lezione del 25/05/2018: Factory, Builder, Singleton

Separare la creazione degli oggetti. Il Simple Factory e il Factory Pattern. Permettere una singola istanza per una classe: il Singleton Pattern. L'esempio di Paperino e della rete semantica. Il Builder pattern.

Lab del 23/05/2018: esercizi su ricorsione, stream e design pattern

Ricorsione: generazione di stringhe binarie con predicato filtrante; visita e stampa ricorsiva del contenuto di una cartella. Stream: l'esercizio Titolo con tutti i punti (ultima diapositiva della lezione sugli stream). Design pattern: array con ordinamento flessibile (strategy pattern).

Lezione del 22/05/2018: design pattern; reactive stream; esercizio su ricorsione

Che cos'è un design pattern. Lo Strategy Pattern: il simulatore di anatre. L'Observer Pattern: un'applicazione di monitoraggio del tempo. La metafora dell'abbonamento. java.util.Observable e java.util.Observer. Reactive stream: Publisher, Subscriber, Subscription e Processor. Esercizio sulla ricorsione: generare tutte le stringhe binarie di lunghezza n.

Lezione del 18/05/2018: la ricorsione

La ricorsione. Pensare ricorsivamente. Esempio: il fattoriale. Funzionamento della ricorsione: record di attivazione e stack. Non prevedere un caso base: la ricorsione infinita. Esempi: riconoscimento di una stringa palindroma, concatenazione ricorsiva di stringhe, ricerca binaria ricorsiva. Utilizzo di metodi di comodo mediante l'overloading. Strutture dati  Esercizi sulla ricorsione: ricerca binaria.
Esercizi: riconoscimento di una stringa palindroma, concatenazione ricorsiva di stringhe. Utilizzo di metodi di comodo mediante l'overloading. Strutture dati ricorsive. Esercizi sulla ricorsione: generazione di tutte le combinazioni di caratteri; generazione delle permutazioni di una stringa. Labirinto con definizione ricorsiva e mediante matrice labirinto. Mutua ricorsione. 

Lab del 16/05/2018: esercizi sugli stream e homework 3

Esercizi sugli stream: filter, map, IntStream, mapToObj, iterate, collect, Collectors.toList, Collectors.joining. Scrittura del JUnit test dell'homework 3.

Lezione del 15/05/2018: ancora sugli stream

Differenza tra iterazione interna ed esterna. Metodi di Stream: map, limit, skip, collect. Collectors: counting, maxBy/minBy, summingInt, averagingInt, joining, toList, toSet. toCollection, mapping, summingInt, averagingInt. Operazioni intermedie: limit, skip, flatMap. L'operazione terminale reduce. Operazioni su IntStream, DoubleStream, LongStream e passaggio da uno stream all'altro. Ottenere uno stream infinito. L'operazione intermedia flatMap. Ottenere uno stream infinito e iterare su uno stream: il metodo Stream.iterate. Copiare gli stream. Importanza dell'ordine delle operazioni. Ottimizzazione dell'ordine di esecuzione. Stream sequenziali e paralleli.

Lezione dell'11/05/2018: stream e annotazioni

Breve introduzione alla reflection, concetto di classe Class e ottenimento dell'istanza di Class da istanze e da classi. Class.forName. Le annotazioni in Java. La classe Optional. Gli stream: definizione; caratteristiche; operazioni intermedie e terminali. Metodi principali dell'interfaccia java.util.stream.Stream. Comportamento "pigro" (lazy) degli stream. Operazioni senza stato e con stato. Stream ottimizzati per i tipi primitivi: IntStream, DoubleStream e LongStream. Come ottenere uno stream: da elenco di valori, da una Collection, da un array, da un file. Il pattern Builder, la sua importanza nel paradigma orientato agli oggetti e il suo uso negli stream mediante operazioni intermedie e terminali. Operazioni intermedie e terminali degli stream.

Lab del 09/05/2018: esercizi sui generici; test dell'homework 3

Esercizi sui generici: classe Record; ListaLinkata generica; MultiMappa generica. Definizione della classe JUnit di test dell'homework 3.

Lezione del 08/05/2018 (R): i tipi generici

Introduzione ai tipi generici. Generici e collezioni: interfacce generiche prototipiche. Definire un metodo generico. Calcolare il massimo di una collezione di elementi di tipo generico. Sicurezza dei generici a tempo di compilazione: confronto con gli array. Jolly come tipi generici. Esempio: metodo generico di somma. Cancellazione del tipo (type erasure). Esempio: cancellazione del tipo nella classe Coppia e nel metodo getMassimo. Esercizio: cancellazione del tipo nella classe Pila.

Lezione del 04/05/2018: riferimenti a metodi; metodi di Comparator; interfacce funzionali standard; pila e coda.

Espressioni lambda per specificare il Comparator. Riferimenti a metodi: statici, d'istanza con riferimento, d'istanza con classe. Ordinamento di una collection in Java 8 vs. Java 7. Metodi di default e statici dell'interfaccia Comparator. Interfacce funzionali standard: Predicate, Function, Supplier, Consumer. Pila e coda in Java.

Lab del 02/05/2018: Comparator con lambda, Comparator.comparing, MultiMappa con generici e metodi Java 8 di Map, singoletto

Espressioni lambda per specificare il Comparator e Comparator.comparing per mappare gli oggetti all'elemento di comparazione.MultiMappa con generici e metodi Java 8 di Map. Il design pattern del singoletto. Paperinik/Paperino e supereroi con il singoletto e le classi statiche annidate.

Lezione 27/04/2018: le Collection (1/2)

Le Collection. Gerarchia delle interfacce di tipo Collection: Iterable, Collection, List, Set, SortedSet, Queue. Tre modi per iterare su una collezione. L'interfaccia Iterator. Esempio: il Jukebox. Collezioni fondamentali: ArrayList, LinkedList, HashSet, TreeSet, HashMap, LinkedHashMap, TreeMap. Metodi di ogni collezione. ListIterator e il metodo listIterator. Esempi di uso di HashSet e TreeSet. Funzionamento di un HashSet: il metodo hashCode. HashMap e TreeMap: l'interfaccia Map. L'interfaccia Comparable. Ordinamento con l'interfaccia Comparator. Insiemi e mappe con elementi (o chiavi) senza ordinamento, con ordinamento naturale e con ordinamento di inserimento. I metodi keySet, values e entrySet di Map. Espressioni lambda per specificare il Comparator.

Lezione del 24/04/2018 (ER): Eccezioni

Eccezioni. Casi tipici nella programmazione Java. Eccezioni notevoli. Perché non restituire un valore d'errore. Vantaggi e svantaggi delle eccezioni. Cosa gestire e cosa non gestire con le eccezioni. Il blocco try-catch-finally. La politica catch-or-declare: gestire o ignorare le eccezioni. Creare eccezioni personalizzate. Le parole chiave throw e throws. La classe Throwable. La gerarchia delle eccezioni in Java. Le classi Exception e Error. Eccezioni checked e unchecked. Esercizi (da svolgere a casa): SequenzaAGradini, FloppyDisk, Dizionario e Mappa, Catena di volontari.

Esonero 2 (17/4/2018)

Ci siamo messi alla prova!

Lezione del 13/04/2018: esercizi di preparazione all'esonero

Lezione importante di preparazione all'esonero. L'esercizio EssereVivente, con eccezioni, classi e metodi astratti, polimorfismo, ecc. Implementazione di interfacce (esercizio Cercabile). Introduzione dell'interfaccia Set e sua implementazione HashSet. Importanza dell'implementazione di equals e hashCode (es. Tupla2) in relazione al funzionamento di List e Set. Metodo Objects.hash per calcolare l'hashCode degli oggetti di una classe. Classi interne e anonime, interfacce funzionali e lambda. Aggiungere la funzionalità di comparabilità durante l'implementazione di una classe (Comparable<T>) e dopo aver chiuso il codice di una classe (l'interfaccia funzionale Comparator<T>). Ordinamento mediante Comparator: Collections.sort(lista, comparator) e List.sort(comparator). Esempi di espressioni lambda. Utilizzare le espressioni lambda per implementare un comparator e per implementare funzioni arbitrarie (es. FunzioniSuInsieme).

Lab dell'11/04/2018: iterabilità (Iterable e Iterator), comparabilità (Comparable vs. Comparator), classi interne, classi annidate, classi anonime, interfacce funzionali, lambda

Esercizi su classi interne: l'esempio della lista linkata di elementi interi implementati mediante classe statica annidata. Iterabilità: iteratore un testo per righe; iterare una lista linkata implementando l'interfaccia java.lang.Iterable e l'interfaccia java.util.Iterator mediante classe interna o classe anonima (sua definizione). Le interfacce Comparable e Comparator. Intefacce funzionali. Espressioni lambda.

Lezione del 10/04/2018 (8.15-10.30+12.50-14.10): metodi e classi final; interfacce. Iterabilità mediante Iterator e Iterable.

Metodi e classi final. Interfacce in Java: dichiarazione, implementazione. Esempio: Iterabile. Differenza tra interfacce e classi astratte. Ereditarietà multipla: il problema del diamante. Interfacce notevoli. Esercizio: MyString con Iterator e Iterable. Interfacce notevoli. Classi interne e anonime.

Lezione del 06/04/2018: polimorfismo e classe Object

Polimorfismo: definizione, esempi e casistiche. Esempi: la classe Impiegato, ImpiegatoStipendiato e ImpiegatoACottimo. La parola chiave super per accedere a metodi e campi della superclasse. L'operatore instanceof. Downcasting e upcasting: differenze ed effetti sull'interfaccia pubblica. La classe universale Object e i suoi metodi principali: clone, equals, getClass, hashCode, toString. Sovrascrivere i metodi toString, equals e clone.

Lab del 04/04/2018: espressioni matematiche, debugger in Eclipse, generazione javadoc, moduli Java 9, ArrayList e suoi metodi, Javafx e Jetris

Laboratorio molto denso: esercizio Espressioni Matematiche per verificare la conoscenza di ereditarietà e polimorfismo, con due soluzioni: mediante sottoclassi di EspressioneBinaria e mediante enumerazioni di EspressioneBinaria. Debugger in Eclipse.  enerazione automatica della documentazione javadoc. Brevissima introduzione ai moduli Java 9: module-info.java, parole chiave module, exports, requires, requires transitive. ArrayList e i suoi metodi, javafx e Jetris. Il costrutto "for each".

Lab del 28/03/2018: esercizi sull'ereditarietà

Esercizi (dalle diapositive): BarraDiEnergia, ListaOrdinataDiInteri, Tetris.

Lezione del 27/03/2018: ereditarietà

Una lezione molto molto importante sull'ereditarietà: abbiamo introdotto il concetto di ereditarietà, di classi e metodi astratti, parole chiave this e super nei costruttori. Funzionamento dei costruttori nella gerarchia di ereditarietà. Differenza tra overriding e overloading. Visibilità di campi e metodi: pubblica, privata, protetta e di package. Introduzione a JUnit.

Lezione del 23/03/2018: prova!

Ci siamo messi alla prova!

Lab del 21/03/2018: esercizi di preparazione

Esercizi su heap & stack ed esercizi di preparazione alla prova scritta (GestoreArray e StringaMangiona).

Lezione del 20/03/2018: metodi e campi statici; enumerazioni; classi wrapper; autoboxing/unboxing

Vantaggi dei metodi e dell'incapsulamento. Metodi e campi statici: modalità di accesso dall'interno e dall'esterno della classe. Perché il main() è static? Importazione statica di campi e metodi.

Enumerazioni. Esempio: SemeCarta e ValoreCarta. Dichiarazione di una enumerazione. Costruttori, campi e metodi di un'enumerazione. I metodi values e valueOf. Enumerazioni e switch.

Autoboxing (vedi immagine sotto :-)), auto-unboxing. Classi wrapper e metodi e costanti delle classi wrapper. Confrontare valori di tipi primitivi vs. oggetti vs. valori di enumerazioni. Esercizi su heap & stack.

Lezione del 16/03/2018: gli array; esercizio su heap & stack

Gli array. Definizione, inizializzazione, accesso agli elementi, lunghezza di un array. Matrici mediante array di array. Esercizio su heap & stack.

Lab del 14/03/2018 (S): stringhe, costrutti di controllo e di iterazione

Esercizi su stringhe, flussi di controllo (switch-case), operatori di pre/post incremento e cicli for/while. Dopo aver svolto una serie di semplici esercizi per ognuna delle tematiche sopra citate, abbiamo affrontato nel dettaglio l'esercizio Cornice. Siamo partiti dalla definizione di un metodo statico in grado di stampare una matrice di caratteri NxN, abbiamo arricchito il metodo aggiungendo la possibilità di inserire una stringa all'interno della cornice ed infine, chiarendo la differenza tra metodo statico e metodo di istanza, abbiamo strutturato la classe CorniceStampabile definendo i campi, due costruttori (overloading) ed il metodo di classe toString(), focalizzando l'attenzione sulle buone norme di scrittura del codice.

Lezione del 13/03/2018 (ER): decisione (if, ?, switch); iterazione (while, for)

Strutture di controllo: if, else, il problema dell'else sospeso, else if, operatore di selezione ?, istruzione switch. Esercizi: estrazione del carattere centrale, saluto casuale. Introduzione ai costrutti iterativi: while, do..while, for. Le istruzioni break e continue. Eleganza del codice e coding horror.

Lezione del 09/03/2018: la classe String e i suoi metodi; heap & stack

La classe String e i suoi metodi. Riferimenti e oggetti. Anatomia della memoria: stack e heap. Metodi statici.

Lab del 07/03/2018: esercizi

HelloWorld compilato con javac ed eseguito con java. Esercizi sulle espressioni booleane, interi e double. Esercizi sulle conversioni di tipo. L'esercizio Rettangolo e l'importanza dell'incapsulamento mediante implementazione privata.

Lezione del 06/03/2018: classi e oggetti, campi, metodi e costruttori

Consapevolezza del tipo di dato. Conversione esplicita, cast esplicito, cast implicito. Concetti fondamentali di programmazione orientata agli oggetti: classi vs. oggetti, campi e metodi (inclusi i costruttori) e politiche di accesso. Esercizi: La classe Contatore. 

Lezione del 02/03/2018: Introduzione al corso (2), concetti fondamentali, JDK, jshell, tipi primitivi, letterali e variabili

Oggi abbiamo completato l'introduzione al corso, fornito una panoramica sugli argomenti principali del corso (oggetti, incapsulamento, ereditarietà, polimorfismo) e parlato di tipi di dato primitivi, variabili, identificatori e letterali. Installazione di JDK ed Eclipse. Introduzione a JShell.

Lezione del 28/02/2018

E la prima lezione è andata!!! Abbiamo anche introdotto brevemente i progetti (ne riparleremo più avanti in queste settimane). Non dimenticatevi di iscrivervi al gruppo di discussione.

AVVISO IMPORTANTE

IMPORTANTE: La lezione di mercoledì 28 del corso di metodologie di programmazione (M-Z), essendo introduttiva del corso, è anticipata alle ore 11 e sarà svolta in aula P1, invece che in laboratorio.

Si parte!

Benvenuto/a! Se sei uno studente del corso di Metodologie di Programmazione (prof. Navigli), segui le istruzioni qui riportate per iscriverti: gruppo di discussione e materiale. Come ogni anno, il corso sarà aggiornatissimo, coinvolgente ed entusiasmante! Quest'anno scriveremo un videogioco che conoscete molto bene!