Programmazione

Anno Accademico 2013/2014 - Edizione 1

Docente: Giovanni Pighizzini

Home page programmazione
Esami
FAQ - Domande frequenti

Indice del libro di testo

• 2 ottobre 2013 - Lezione 1
  Presentazione del corso. L'evoluzione della programmazione. Algoritmi e programmi. Informazione.

• 4 ottobre 2013 - Lezione 2
  Dispositivi hardware. Classificazione del software. La macchina di Von Neumann e i linguaggi macchina.

• 7 ottobre 2013 - Lezione 3
  Dai linguaggi macchina ai linguaggi ad alto livello. Compilatori e interpreti. Editor, linker e librerie. Il compilatore Java. Bytecode e Java Virtual Machine. La programmazione strutturata (inizio): sequenza. Variabile e assegnamenti.

• 9 ottobre 2013 - Lezione 4
  La programmazione strutturata (continuazione): selezione, iterazione. Esempi vari.

  Cosa sappiamo fare? Cosa abbiamo imparato?
  Arrivato a questo punto del corso, lo studente deve conoscere il concetto di variabile e l'operazione di assegnamento.
  Lo studente deve imparare a progettare ed esprimere, mediante le strutture di controllo fondamentali, algoritmi per la risoluzione di semplici problemi, come quelli presentati a titolo d'esempio a lezione e nel primo capitolo del libro di testo. Per acquisire queste capacità è indispensabile che lo studente si cimenti autonomamente nella risoluzione di esercizi. Il primo capitolo del libro propone numerosi esercizi utili a questo scopo. Ulteriori esercizi (alcuni semplici, altri un po' più complessi) si trovano a questo link.
  È inutile affrontare gli argomenti successivi se non si è in grado di risolvere autonomamente questo tipo di esercizi.

• 11 ottobre 2013 - Lezione 5
  Esempi di cicli infiniti. Dalla programmazione strutturata alla programmazione a oggetti. Aspetti sintattici dei linguaggi di programmazione: grammatiche, Backus-Naur Form, carte sintattiche. Alcuni aspetti della grammatica del linguaggio Java. Il primo programma Java.

• 14 ottobre 2013 - Lezione 6
  Il riferimento predefinito System.out e alcuni metodi print e println. Protocolli e contratti. Costruttori e operatore new. Invocazione di metodi e costruttori. Variabili per riferimenti. Il riferimento null. Alcuni esempi di costruzione di oggetti e invocazione di metodi. Direttive di importazione. Esempi introduttivi.

• 16 ottobre 2013 - Lezione 7
  Metodi: prototipi e segnature. Overloading di metodi, costruttori e operatori. L'overloading dell'operatore +. Variabili e tipi. Tipi primitivi e tipi riferimento. Assegnamenti e confronti nel caso di tipi primitivi e di tipi riferimento.
  Esercizi relativi all'overloading dell'operatore +.

• 21 ottobre 2013 - Lezione 8
  La classe String: alcuni costruttori e metodi. Esercizi ed esempi sull'uso delle classi e sulla scrittura di metodi main che utilizzino esclusivamente istruzioni in sequenza.

  Cosa sappiamo fare? Cosa abbiamo imparato?
  Arrivato a questo punto del corso, lo studente deve essere in grado di svolgere autonomamente tutti gli esercizi proposti nei primi due capitoli del libro di testo. In particolare, lo studente deve sapere scrivere applicazioni basate su metodi main con istruzioni in sequenza, che utilizzino i comportamenti offerti da oggetti di svariate classi. Gli studenti sono invitati a prestare particolare attenzione agli esercizi alla fine del secondo capitolo. È inutile affrontare gli argomenti successivi senza avere acquisito queste semplici abilità.

• 23 ottobre 2013 - Lezione 9
  Il costrutto di selezione in Java. Il tipo primitivo boolean. La lazy evaluation. Semplici esempi di scrittura di condizioni. Esempio: la classe Importo.
  Esercizi aggiuntivi sull'uso delle classi

• 25 ottobre 2013 - Lezione 10
  Il ciclo do-while. Il ciclo while. Esempi.
  Esempi ed esercizi relativi ai cicli do-while e while.

• 28 ottobre 2013 - Lezione 11
  I metodi statici. Il tipo primitivo char e la classe Character. Il ciclo for. Quando utilizzare e non utilizzare il ciclo for. Le istruzioni break e continue.
  Esempi ed esercizi aggiuntivi.

  Cosa sappiamo fare? Cosa abbiamo imparato?
  A questo punto è stato presentato tutto il materiale dei primi tre capitoli del testo (e alcuni argomenti del quarto). Ora lo studente deve essere in grado di scrivere applicazioni basate su metodi main (con costrutti di sequenza, selezione e iterazione), in grado di utilizzare oggetti di svariate classi. Gli studenti sono invitati a prestare particolare attenzione agli esercizi proposti nel terzo capitolo del testo e a questi ulteriori esercizi.

• 30 ottobre 2013 - Lezione 12
  Introduzione ai tipi generici: la classe Sequenza e la classe SequenzaOrdinata. Il ciclo for-each. La classe involucro Integer. Il tipo riferimento Integer e il tipo primitivo int: autoboxing e unboxing.
  Esempi ed esercizi aggiuntivi.

  Nota
  Nelle lezioni successive saranno completati gli argomenti dei capitoli 4 e 5 del libro di testo. Con quanto visto sinora gli studenti possono già risolvere gli esercizi proposti dopo il paragrafo 5.7 (eccetto gli esercizi 5.21, 5.22, 5.24 che fanno riferimento a esempi sugli array, argomento non ancora trattato).

• 4 novembre 2013 - Lezione 13
  Tipi primitivi e classi involucro: perché in Java ci sono entrambi. Le espressioni e gli effetti collaterali. L'operatore condizionale. I tipi numerici interi. Conversioni implicite (promozioni) ed esplicite (forzature o cast) tra tipi primitivi interi.

• 6 novembre 2013 - Lezione 14
  I tipi numerici in virgola mobile. Conversioni implicite ed esplicite tra valori interi e valori in virgola mobile. Perdita di informazione e perdita di precisione. Costanti e importazione statica. Divisione per zero nei tipi interi e nei tipi in virgola mobile. I valori NaN e infinito positivo e negativo per i tipi in virgola mobile.

• 8 novembre 2013 - Lezione 15
  I tipi enumerativi. L'istruzione switch.
  Esempi.

• 11 novembre 2013 - Lezione 16
  Gli array. Costruttori per gli array. Riferimenti ad array. Il parametro del metodo main. Significato dell'intestazione del metodo main. Array e cicli for.
  Esempi ed esercizi aggiuntivi.

• 13 novembre 2013 - Lezione 17
  Ulteriori esempi sugli array. Array e tipi enumerativi. Array di array.
  Esempi ed esercizi aggiuntivi.

• 15 novembre 2013 - Lezione 18
  Introduzione all'ereditarietà: le classi Rettangolo e Quadrato. Supercassi e sottoclassi. Supertipi e sottotipi. Polimorfismo. Conversioni implicite (promozioni) ed esplicite (forzature o cast) tra tipi riferimento. L'operatore instanceof.

• 20 novembre 2013 - Lezione 19
  Ereditarietà. Overriding e polimorfismo. Chiamate di metodi: compilazione ed esecuzione. Le classi Cerchio e Figura. Uso del supertipo comune.

• 22 novembre 2013 - Lezione 20
  Metodi astratti. Classi astratte. La classe Object e la gerachia delle classi. I file di testo: la classe FileInputManager e il tipo riferimento InputManager del package prog.io.
  Esempi ed esercizi aggiuntivi.

• 25 novembre 2013 - Lezione 21
  Le interfacce Java. Interfacce e tipi riferimento. La gerarchia dei tipi. L'interfaccia Comparable. Esempi di classi che implementano Comparable. Esercizi riassuntivi su gerarchia delle classi e gerarchia dei tipi.
  Esempi ed esercizi aggiuntivi.

• 27 novembre 2013 - Lezione 22
  Le eccezioni: comportamento dei programmi in caso di eventi anomali. Come intercettare le eccezioni: il costrutto try/catch.
  Esempi ed esercizi aggiuntivi.

  Nota
  In questa lezione e nella successiva, le eccezioni vengono presentate dal punto di vista dell'uso. Altri aspetti relativi alle eccezioni (principalmente la definizione di nuove eccezioni e come creare e sollevare le eccezioni durante l'esecuzione per segnalare eventi anomali) verranno trattati più avanti nel corso, insieme all'implementazione delle classi. Nel libro di testo tutti questi argomenti sono riuniti nel capitolo 11. Il materiale relativo a questa lezione si trova principalmente nei paragrafi 11.1, 11.2, 11.3, con esempi differenti rispetto a quelli discussi a lezione e disponibili su queste pagine. Altre parti del capitolo 11 verranno trattate in seguito.

• 2 dicembre 2013 - Lezione 23
  Le gerarchia delle eccezioni. Ulteriori esempi sulle eccezioni. La gerarchia delle eccezioni (continuazione). Classificazione delle eccezioni: eccezioni controllate, eccezioni non controllate, errori. Come delegare le eccezioni: significato di throws. La classe FileReader del package java.io.
  Esempi ed esercizi aggiuntivi.

  Nota
  Nel libro di testo le eccezioni controllate, le eccezioni non controllate e gli errori sono discussi nei paragrafi 11.8, 11.9, 11.10. Gli esempi del paragrafo 11.8 si riferiscono all'implementazione della classe Frazione, che verrà presentata successivamente nel corso. In questa lezione (e nella successiva) l'argomento viene discusso utilizzando gli esempi relativi alla visualizzazione di un file di caratteri.

• 4 dicembre 2013 - Lezione 24
  Stream di caratteri: le classi Reader, Writer ed alcune sottoclassi. Lettura e scrittura mediante FileReader, BufferedReader, FileWriter, BufferedWriter.
  Esempi ed esercizi aggiuntivi.

• 6 dicembre 2013 - Lezione 25
  Stream di byte: InputStream, OutputStream e alcune sottoclasi. I riferimento predefinito System.in per l'input da tastiera. I riferimenti predefiniti System.out e System.err per l'output sul monitor.
  Esempi ed esercizi aggiuntivi.
  Implementazione delle classi. Stato degli oggetti: campi o attributi. Uso del modificatore private per nascondere l'implementazione all'interno del codice. Costruttori. Metodi. Implementazione di interfacce da parte di classi. Esempio: implementazione della classe Frazione.
  • Implementazione "immediata" (costruttore, alcuni metodi).
  • Implementazione dell'interfaccia Comparable da parte di Frazione.

• 9 dicembre 2013 - Lezione 26
  Implementazione delle classi. Come sollevare le eccezioni: l'istruzione throw. Esempio: implementazione della classe Frazione (continuazione).
  • Implementazione con semplificazione della frazione nel costruttore con due argomenti.
  • Implementazione sollevando ArithmeticException nel costruttore con due argomenti nel caso di denominatore 0.
  Implementazione di classi mediante estensione di classi esistenti. Esempio: implementazione di Quadrato.
  Come definire nuove eccezioni. Eccezioni controllate: quando intercettare e quando delegare. Esempio: FrazioneException e la classe Frazione.

  Nota
  Gli esempi relativi alla classe Frazione presentati in questa lezione e nella precedente si trovano nei paragrafi 7.1, 7.2, 7.3, 7.7, 11.6, 11.7 e 11.8 del libro di testo.

• 11 dicembre 2013 - Lezione 27
  Implementazione delle classi: campi statici e metodi statici. Esempio: la classe Orario. Organizzazione in package. Come documentare le classi: commenti di documentazione e il programma javadoc. Modificatori di visibilità public e private. Visibilità amichevole (o a livello di package).

• 13 dicembre 2013 - Lezione 28
  Riepilogo sulla struttura delle classi: campi, campi statici, costruttori, metodi, metodi statici. Variabili locali dei metodi/costruttori e parametri. Il garbage collector.
  Ereditarietà e stato degli oggetti. Esempi. Usi di this e super: per l'invocazione di costruttori da parte di altri costruttori e come riferimenti. Costruttori e gerarchia delle classi.
  Esempi ed esercizi aggiuntivi.

• 16 dicembre 2013 - Lezione 29
  Overloading di metodi e costruttori: scelta della segnatura del metodo da parte del compilatore. Overloading, overriding e scelta del metodo da eseguire: il ruolo del compilatore e quello dell'esecutore. Come scrivere il metodo equals in modo da ridefinire il metodo offerto da Object.
  Adombramento. Il modificatore final.
  Esempi ed esercizi aggiuntivi.

• 18 dicembre 2013 - Lezione 30
  Implementazione della classe Figura. Invocazione di metodi e passaggio dei parametri. Passaggio per valore (unico meccanismo disponibile in Java). Cenni ad altri meccanismi per il passaggio dei parametri (offerti da altri linguaggi di programmazione). Passaggio dei parametri per valore: passaggio di riferimenti per valore e modifiche agli oggetti. Metodi con un numero variabile di argomenti. Metodi ricorsivi (introduzione).
  Esempi ed esercizi aggiuntivi.

• 20 dicembre 2013 - Lezione 31
  Metodi ricorsivi. Esempi vari.
  Esempi ed esercizi aggiuntivi.

• 8 gennaio 2014 - Lezione 32
  Organizzazione della memoria durante l'esecuzione: memoria statica, stack, heap. Record di attivazione e loro struttura. Evoluzione dello stack durante l'esecuzione: chiamata di metodi, rientro dai metodi. Esempi.

• 10 gennaio 2014 - Lezione 33
  Ulteriori esempi con metodi ricorsivi. La notazione postfissa. Esempio: costruzione di una calcolatrice in notazione postfissa.

• 13 gennaio 2014 - Lezione 34
  La calcolatrice in notazione postfissa: situazioni anomali e loro trattamento. Esercizi (svolti in aula n. 1, 2, 3).

• 15 gennaio 2014 - Lezione 35
  Esercizi

• 17 gennaio 2014 - Lezione 36
  Esercizi