Programmazione orientata agli oggetti - Object Oriented Programming
Docente
- Prof. Giorgio Brajnik
Indirizzo e-mail
Indirizzo Pagina Web Personale
Crediti
9 CFU
Finalità e abiettivi formativi
Lo scopo del corso è di sviluppare la competenza di “pensare ad oggetti” quando si programma un sistema relativamente complesso (non una singola unità, ma centinaia di unità sviluppate insieme ad altre decine di programmatori).
Al termine del corso (e del laboratorio, che ne è parte integrante per 3 CFU) uno studente dovrebbe:
- aver capito come assegnare le responsabilità a un insieme di componenti
- aver capito come definire interfacce dei vari componenti
- aver capito come creare astrazioni e come specificarle
Inoltre, lo studente avrà sviluppato esperienza nell'uso di strumenti tipici della programmazione in Java quali: eclipse, git, maven, junit, log4j, tomcat. Infine avrà fatto pratica di uso e lettura di Java.
Il corso sarà offerto in modalità blended learning.
Programma
Darò per scontati una serie di prerequisiti: esperienza nella programmazione in Java, capacità di installare e configurare applicazioni nel proprio sistema operativo, concetti di base di un sistema operativo (processi, memoria, scheduling, file system, periferiche). Gli esempi che farò faranno riferimento a un sistema ubuntu.
Il contenuto del corso si articola in:
- Tipi di astrazioni: parametrizzazione, specifica procedurale, astrazione sui dati, sui tipi, sulle iterazioni.
- Concetti di base di Java: package, classe, oggetti, variabili, allocazione in memoria; mutability; chiamate dei metodi; type checking; overloading; dispatching dei metodi; tipi di base (vettori, array, collections, mappe, stringhe); tipi parametrici.
- Astrazione procedurale: la specifica, le asserzioni, le eccezioni: checked, unchecked; definizione di nuove eccezioni; gestire le eccezioni con reflection e masking; buone pratiche; overloading.
- Astrazione sui dati: tipi di dati astratti, la loro specifica algebrica; gli invarianti.
- Astrazione sull'iterazione: uso e specifica di iteratori; invarianti.
- Design con Card-Responsibility-Collaboration; stato e comportamento; single responsibility principle.
- Astrazione sui tipi: assegnamento e dispatch; classi astratte; interfacce; substitution principle; uguaglianza; polimorfismo; ereditarietà: specializzazione, specifica, per costruzione, per estensione, per limitazione, per combinazione. Tipi parametrici. Classi interne, closure, callback.
- Design pattern: factory, singleton, composite, decorator, observer, strategy, command, visitor, bridge.
- Threads: race conditions, sincronizzazione, sleep, wait, notify; deadlocks.
Nella parte di laboratorio copriremo:
- uso dei tool di base
- svolgimento di sessioni di debug
- Lettura di codice: su esempi open-source; stili di scrittura. Analisi di pacchetti standard quali commons-io, commons-collections, files NIO.
Le lezioni saranno sia frontali in aula, sia esercitazioni in laboratorio, sia da svolgere autonomamente via elearning. Durante le lezioni verranno assegnati esercizi la cui soluzione concorrerà al voto d'esame; gli esercizi saranno da svolgere via elearning. Le lezioni in aula affronteranno gli aspetti centrali di un argomento: è compito dello studente rivedere tutti i concetti espandendoli se serve.
Bibliografia
Il libro di testo principale è
- B Liskov e J Guttag. Program Development in Java: Abstraction, Specification and Object Oriented Design, 2001. ISBN: 0201657686. Addison-Wesley Professional.
Altri libri da cui traggo parte del materiale sono:
- T. Budd. Understanding Object Oriented Programming with Java, 2002. ISBN: 0201787040 , Pearson.
- B Eckel. Thinking in Java, ISBN: 0131872486, 2006. Prentice Hall; 4 edition.
Modalità d'esame
L'esame sarà basato su una prova scritta, su esercizi svolti durante le lezioni, e un eventuale esame orale.
Orario di ricevimento
Martedì alle 16.30 presso lo studio del docente.
**********************************************************************************
Objectives of the Course
The goal of this course is to help students develop the ability “to think with objects” when they write programs, especially “in the large” (not just a compilation unit, but several hundred, potentially developed by dozens of programmers).
At the end of the course the student should have understood:
- how to assign rensponsibilities to different components
- how and when to define interfaces of components
- how to create abstractions and how to specify them.
Furthermore, the student is expected to build experience in using typical development tools, such as eclipse, git, maven, junit, log4j, tomcat. Practice in reading and understanding complex Java programs should also ensue.
The course will be offered as blended learning.
Programme
Some competences are assumed as pre-requisites: ability to write and run code in Java, apility to install and configure applications, basic notions of operating systems (process, memory, scheduling, file system, peripheral devices). My examples will be based on Ubuntu.
The syllabus of the course includes:
- Abstractions: by parametrization, by specification, abstraction on data, on procedures, on iterations.
- Basic Java notions: packages, classes, objects, variables, memory allocation, mutability, method calls, type checking; overloading; method dispatch; basic types (vectors, arrays, collections, maps, strings). Parametric types.
- Procedural abstractions: specification, assertions, exceptions; reflection and masking; overloading.
- Data abstraction: abstract data types, algebraic specification; invariants.
- Iterators: usage and specification, invariants.
- Card-Responsibility-Collaboration design; state and behavior; single responsibility principle.
- Type abstraction: assignament and dispatch; abstract classes; interfaces; substitution principle; equality; polymorphism; inheritance. Parametric types; Internal classes; closures; callbacks.
- Design patterns: factory, singleton, composite, decorator, observer, strategy, command, visitor, bridge.
- Threads: race conditions, synchronization, sleep, wait, notify; deadlocks.
During the lab we will:
- use basic tools;
- run debug sessions;
- Read Java code: withopen source examples; programming styles.
Lectures will be in the classroom, in the lab and some should be carried out autonomously by the student through an elearning system. During lectures assignements will be given, whose outcome will influence the final score. These assignements will have to be done through the elearning system.
Lectures delivered in the classroom will cover the most important concepts; the student is expected to autonomously fill out missing details whenever needed.
Bibliography
The main text book is:
- B Liskov e J Guttag. Program Development in Java: Abstraction, Specification and Object Oriented Design, 2001. ISBN: 0201657686. Addison-Wesley Professional.
Other books that I will refer to are:
- T. Budd. Understanding Object Oriented Programming with Java, 2002. ISBN: 0201787040 , Pearson.
- B Eckel. Thinking in Java, ISBN: 0131872486, 2006. Prentice Hall; 4 edition.
Exam
The final examination will be based on a written test, the assignements given during the lectures, and a possible oral discussion.