Lezione del 31/05/2019: ancora sui pattern (3/3) e conclusione del corso

Permettere una singola istanza per una classe: il Singleton Pattern. L'esempio di Paperino e della rete semantica. Il Builder pattern.

Il pattern Callback. Riassunto dei design pattern. Consigli per il futuro. Conclusione del corso!

Lab del 29/05/2019: esercizi su ricorsione e design pattern

Esercizi sulla ricorsione: il labirinto del Minotauro (visita ricorsiva). Generare tutte le stringhe binarie di lunghezza n.

Lezione del 28/05/2019: design pattern (2/3)

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.

Lezione del 24/05/2019: i moduli e lo strategy pattern (1/3)

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).


Che cos'è un design pattern. Lo Strategy Pattern: il simulatore di anatre.

Lab del 22/05/2019: esercizi su ricorsione

Teseo e il labirinto (a matrice). Copia ricorsiva di una stringa. Stringa generalizzata.

Lezione del 21/05/2019: I/O e reflection

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 e il serialVersionUID. La parola chiave transient. La reflection, la classe Class, istanziare e ispezionare una classe a tempo di esecuzione.

Lezione del 17/05/2019: le 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.

Lab del 15/05/2019: esercizi su ricorsione e generici

Stampa e generazione di stringhe binarie di lunghezza k e di stringhe arbitrarie di caratteri.

Lezione del 14/05/2016: la ricorsione; ancora sui generici

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.

 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. 

Lezione del 10/05/2019: ancora sugli stream; la ricorsione

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. IntStream.range e rangeClosed. Copiare gli stream. Importanza dell'ordine delle operazioni. Ottimizzazione dell'ordine di esecuzione. Stream sequenziali e paralleli.

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.

Lab dell'8/5/2019: esercizi su stream

Esercizi su stream, esercizi su stream, esercizi su stream (vedi file caricato sul gruppo).

Lezione del 7/5/2019: 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. Importanza dell'ordine delle operazioni. Stream sequenziali e paralleli.

Lezione del 3/5/2019: ancora sui generici e introduzione agli stream

Introduzione ai tipi generici. Generici e collezioni: interfacce generiche prototipiche. 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.

Lezione del 30/04/2019: Comparator, interfacce funzionali standard, pila e coda, alberi, grafi. Introduzione ai generici.

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. Introduzione ai tipi generici. Generici e collezioni: interfacce generiche prototipiche.

Lezione del 26/04/2019: Set, Map, Comparator e riferimenti a metodi

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. Espressioni lambda per specificare il Comparator. Riferimenti a metodi: statici, d'istanza con riferimento, d'istanza con classe.

Lab del 17/04/2019: ListaLinkata, sua realizzazione con generici, sua estensione con memorizzazione dell'ultimo elemento; iterabilità con classi interne; interfacce funzionali.

ListaLinkata, sua realizzazione con generici, sua estensione con memorizzazione dell'ultimo elemento; iterabilità con classi esterne ed interne; interfacce funzionali.

Lezione del 16/04/2019: interfacce, classi annidate e interne, interfacce funzionali, espressioni lambda, collections (1/2)

Intefacce funzionali. Espressioni lambda. Le Collection. Gerarchia delle interfacce di tipo Collection: Iterable, Collection, List, Set, SortedSet, Queue. Tre modi per iterare su una collezione. L'interfaccia Iterator. Collezioni fondamentali: ArrayList, LinkedList, HashSet, TreeSet, HashMap, LinkedHashMap, TreeMap. Metodi di ogni collezione. ListIterator e il metodo listIterator.

Esonero dell'8/4/2019

Ci siamo messi alla prova!!!

Lezione del 05/04/2019: interfacce, metodi di default, statici e privati nelle interfacce, iterabilità, esercizi

Le interfacce in Java: metodi pubblici, metodi di default, statici e privati nelle interfacce. Iterabilità mediante le interfacce Iterable e Iterator. Esercizi: DistributoreAutomatico, EssereVivente. SequenzaAritmetica e SequenzaAritmeticaConPasso iterabili. Rendere iterabile un array di stringhe.

Lab del 03/04/2019: esercizi su ereditarietà e polimorfismo

Esercizi: ContoBancario, espressioni matematiche. Rendere iterabile una lista di interi mediante Iterable/Iterator.

Lezione doppia del 02/04/2019: polimorfismo, classe Object e liste

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. Metodi e classi final. Interfacce in Java: dichiarazione, implementazione. Introduzione alle liste; metodi di ArrayList. Introduzione alle interfacce.

Lezione 29/03/2019: 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.

Prova del 27/03/2019

Ci siamo messi alla prova!

Lezione del 26/03/2019: l'esercizio BarraDiEnergia

Esercizio BarraDiEnergia (con varianti) e sua rappresentazione su heap&stack.

Lezione doppia del 22/03/2019: esercizio ListaDiInteri, heap&stack, incapsulamento, metodi/campi statici enumerazioni, tipi wrapper, autoboxing/unboxing

Esercizio ListaDiInteri. 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.

Lab del 20/03/2019: esercizio GestoreArray + heap&stack

Esercizio GestoreArray. Allocazione e copia di array. Implementazioni efficienti. Rappresentazione in memoria: heap & stack.  Metodi d'istanza chiamati di altri metodi.

Lezione del 15/03/2019: esercizi su heap&stack; gli array

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

Lab del 13/03/2019: esercizi su stringhe, heap & stack e if/for

Esercizi: classi Persona, Stringa42, RegistratoreDiCassa, contaParole.

Lezione doppia del 12/03/2019: stringhe, heap & stack, strutture di controllo

La classe String e i suoi metodi. Riferimenti e oggetti. Anatomia della memoria: stack e heap. Metodi statici. 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.

Lab del 06/03/2019 (P): esercizi su classi, oggetti, campi, metodi e costruttori

Esercizi: la classe Persona, la classe Quadrato, la classe Cerchio, la classe BarraDiCompletamento.

Lezione del 01/03/2019: classi e oggetti, campi, metodi e costruttori

Concetti fondamentali di programmazione orientata agli oggetti: classi vs. oggetti, campi e metodi (inclusi i costruttori) e politiche di accesso. Esercizi: la classe Contatore e la classe Menu. 

Lab/lezione del 27/02/2019: JDK, Eclipse, JShell, tipi di dato, espressioni, assegnazione, operatori, conversioni

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. Operatori aritmetici e booleani, operatori di confronto, operatori di assegnazione. Il main di una classe. Consapevolezza del tipo di dato. Conversione esplicita, cast esplicito, cast implicito.

Lezione del 26/02/2019: introduzione al corso

E la prima lezione è andata!!! Abbiamo introdotto Léo Ferré (io vengo da un altro mondo, da un altro quartiere, da un'altra solitudine), il corso, il linguaggio Java e gli elementi di base della programmazione orientata agli oggetti. Non dimenticatevi di iscrivervi al gruppo di discussione.

Si parte!!!

Benvenuto/a! Se sei uno/a studente/essa 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 proporrò un videogioco e un task di Intelligenza Artificiale!!