Lezione 28/5/2015: Esercizi: Singleton, Command, Strategy e Builder

Esercizi sui design pattern: Singleton, Command, Strategy e Builder.

Lab 27/5/2015: esercizi in preparazione dell'esonero/esame

Esercizio sui generici (da matrice a lista) e sulla ricorsione in Java (combinazione di caratteri).

API per il gioco con scopo.

Lezione 26/5/2015: Decorator pattern e conclusione del corso

Il Decorator Pattern: aggiungere responsabilità a una classe senza che essa lo sappia. L'esempio della rappresentazione grafica delle automobili. Conclusione del corso!

Lezione 21/05/2015: AWT e Swing

Lezione sulle interfacce grafiche in Java: AWT e Swing.

Lab 20/05/2015: esercizi

Lezione su LibGDX ed esercizi su design pattern: singleton e strategy pattern.

Lezione 19/05/2015: design pattern (2)

Permettere una singola istanza per una classe: il Singleton Pattern. L'esempio di Paperino e della rete semantica. Il Builder pattern. Il Command Pattern e l'esempio della callback. Rivisitazione del pattern Iterator.

Lezione 14/05/2015: design pattern (1)

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. Separare la creazione degli oggetti. Il Simple Factory e il Factory Pattern.

Lab 13/05/2015: esercizi sugli stream; presentazione dei progetti

Esercizi sugli stream a partire da liste di stringhe e liste di oggetti di tipo Ristorante. Presentazione dei progetti.

Lezione 12/5/2015: gli stream

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. Differenza tra iterazione interna ed esterna. Metodi di Stream: min/max, filter, forEach, count, sorted, map, distinct, reduce, collect, anyMatch, allMatch, noneMatch, findFirst, findAny, mapToInt. Collectors: counting, maxBy/minBy, summingInt, averagingInt, joining, toList, toSet, groupingBy, partitioningBy. Stream paralleli. Le mappe in Java 8. Nuove API data e ora.

Lezione 7/5/2015: la reflection

Introduzione alla Reflection. La classe Class. Ottenere un oggetto di tipo Class: da istanze di tipi non primitivi, da tipi primitivi, da tipi non primitivi, per nome: il metodo Class.forName. Scoprire i campi, metodi e costruttori di una classe. Esempio di uso della Reflection: creare intelligenze artificiali a tempo di esecuzione. Richiamare un determinato metodo a tempo di esecuzione.

Rilascio del codice: i file jar. Creazione di un file jar da console e con Eclipse. Jar eseguibili: il manifesto. Esecuzione di un file jar.

Lab 06/05/2015: esercizi su ricorsione e taginvaders

Ancora sulla ricorsione: mutua ricorsione. Cambio di base ricorsivo. Espansione ricorsiva di una stringa generalizzata. Percorso ricorsivo su un array di posizioni. Esercizio per casa: Labirinto con esplorazione ricorsiva con filo di Arianna(TM). Serializzazione e deserializzazione di oggetti. Checkpoint su taginvaders.

Lezione 05/05/2015: 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 ricorsive. Esempio: visualizzare il contenuto di una cartella in forma gerarchica. Esercizio: cercare file in una cartella, somma ricorsiva di numeri. La successione di Fibonacci, efficienza e problematiche dell'implementazione ricorsiva. Esercizio: permutazioni di una stringa.

Lezione 30/04/2015: I/O

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 File. Leggere e scrivere un file di testo formattato: le classi Formatter e Scanner. Serializzare e deserializzare un oggetto. L'interfaccia Serializable e il serialVersionUID. Esempio: il fumetto serializzabile.

Lab 29/04/2015: esercizi su eccezioni e ricevimento per taginvaders

Esercizio: Successioni numeriche. Esercizio: Sequenza a gradini. Discussione TagInvaders.

Lezione 28/04/2015: 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.

Lezione 23/04/2015: i tipi generici

Tipi generici. Definire e utilizzare una classe generica. Specificare più tipi generici. Estendere le classi generiche. Esercizio: inverti lista generica. 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.

Lab 22/04/2015: hashCode e equals; presentazione dell'esonero 3

Importanza dell'implementazione di hashCode e equals ed esempi di malfunzionamenti con HashSet; importanza dell'implementazione di Comparable per l'uso di TreeSet o TreeMap. Presentazione del terzo esonero: TagInvaders!

Lezione 21/04/2015: le collection (2); riferimenti a metodi; interfacce funzionali standard

hashCode e equals per il corretto funzionamento di HashSet; comparabilità per il funzionamento di TreeSet/Map. 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. Come scegliere la collection appropriata al proprio problema.

Prova intermedia: 17/4/2015

La foto parla da sé!

Lezione del 09/04/2015: le collection (1)

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. Riferimenti a metodi.

Lab 08/04/2015: annullato

Il laboratorio di oggi annullato causa prolungamento inatteso di lavori all'interno.

Lab 01/04/2015: esercizi

Esercizio su interfaccia Resettabile. Esercizio Filtro, FiltroIntero, FiltroPrimo, FiltroDispari, MultiFiltro con gestione delle eccezioni. Rendere iterabile una stringa (con iterator come classe interna). Rendere iterabile un treno (con iterator di vagoni ripreso dall'iterator della lista). Rete sociale e Utenti.

Lezione 31/03/2015: classi annidate e interne; classi anonime; espressioni lambda

Classi interne: classi top-level, classi annidate e interne. Classi anonime. Espressioni lambda. Esercizio: lista linkata con classi interne (provate a farlo con add in coda ottimizzato).

Lezione 26/03/2015: interfacce; esercizio con Iterable e Iterator; for "each"

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. Istruzione for "each"

Lab 25/03/2015: esercizi

ContoBancario e Operazione (in versione Java 7 e Java 8). Espressioni. Debugging con Eclipse.

Lezione 24/3/2015: 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. Sovrascrivere i metodi toString, equals e clone.

Lezione 19/03/2015: ereditarietà (2)

Overriding e overloading. Differenza tra ereditarietà (is-a) e composizione (has-a). Esercizi: BarraDiEnergia e BarraDiEnergiaConPercentuale. Come creare il livello di uno sparatutto con 4 righe di codice.

18/03/2015: ci siamo messi alla prova!

Ho dimenticato di "farvi la foto"... questi sono i vostri colleghi dell'anno scorso:

Lezione 17/03/2015: 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.

Lezione 12/03/2015: ancora su stack & heap e enumerazioni

Esercizi.

Lab 11/03/2015: esercizi

Esercizi: MazzoDiCarte.

Lezione 10/03/2015: enumerazioni, autoboxing e autounboxing

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.

Lezione 05/03/2015: gli array, metodi e campi statici, enumerazioni

Array: dichiarazione, inizializzazione, accesso. Numero variabile di parametri. Array bidimensionali. 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.

Lab 04/03/2015: decisione (if, ?, switch); iterazione (while, for); esercizi.

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. Esercizi: calcolare le potenze di 2 fino a 2^N.

Lezione 03/03/2015: riferimenti e oggetti; stack & heap; campi e metodi statici; Scanner, package

La classe String e i suoi metodi. Riferimenti e oggetti. Anatomia della memoria: stack e heap. Metodi statici. Lettura dell'input da console: la classe Scanner. Package. Package standard e package di default. La dichiarazione import e la parola chiave package.

Lezione 26/02/2015: campi, metodi, costruttori, overloading, accessibilità private e public

Lezione sui concetti fondamentali di programmazione orientata agli oggetti: classi vs. oggetti, campi e metodi (inclusi i costruttori) e politiche di accesso. Esercizi: La classe Contatore.

Lab 25/02/2015: introduzione al corso (2), tipi di dato primitivi, letterali, variabili, 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. Espressioni, operatori aritmetici, operatori di confronto. Un esercizio "collaborativo" per il calcolo di un'espressione in Java. I 3 tipi di conversione di tipo: conversione esplicita, cast esplicito e cast implicito.

Lezione 24/02/2015: introduzione al corso

E la prima lezione è andata!!! Non dimenticatevi di iscrivervi al gruppo di discussione.

Benvenuti!

Il 2015 è arrivato! Se sei uno studente del nuovo corso di Metodologie di Programmazione (prof. Navigli), segui le istruzioni qui riportate per iscriverti: gruppo di discussione e materiale.