NFP121

Programmation Avancée (6 crédits)

 

2015-2016

Avertissements :
  • pour suivre avec profit cette UE il faut suivre régulièrement le cours (1h30 + 1h de compléments, présentation du TP de la semaine), un TD (1h30) et rendre régulièrement des travaux hebdomadaires (TP)

  • les documents associés aux cours (au format PDF) sont accessibles sur le net au fur et à mesure du déroulement du cours (cf. ci-dessous).

L'activité de programmation étant primordiale dans ce cours, les TD seront des TP/TD comportant :

  • une partie de spécification d'un exercice (en séance au cnam)

  • une partie de réalisation d'un exercice (sur machine "à la maison").

  • Le travail réalisé sera rendu chaque semaine sur le web sous deux formes. 

    • un projet Java qui sera testé automatiquement
    • une page html de compte rendu du travail réalisé.
  • pour participer à ces TP il faut d'abord vous identifier par votre nom (en CAPITALES de préférence) et votre numéro d'inscription d'auditeur Cnam (qui vous servira de password, et vous identifiera pour les points de bonus), en l'absence de ce numéro un mot de passe de votre choix :
                          
    pre_inscription aux tp

Les TP seront réalisés par défaut avec BlueJ  la dernière version inclut le JDK (1.8)

Premier cours : mardi 29 Septembre, 18h15,  selon ce lien
   
Au Cnam, 292, rue Saint-Martin - Salle 17-2-15

Première séance d'exercices dirigés : lundi 05 Octobre
    deux groupes au choix, en accès libre, 292, rue Saint-Martin - Salle 17-2-10
 

Les Travaux Pratiques

   Ici les exemples utilisés en exercices dirigés, pendant et après le cours,
   des corrections partielles de certains TP

Certaines Annales...

 

Programme (NFP 121 - Programmation Avancée 2015_2016 HTO et FOD au premier semestre)

 


1. 29/09/15 Introduction, vocable, les essentiels :

Classes, instances,
visibilité, héritage,
spécialisation, surcharge 

2.  06/10/15 Une Classe, et les aspects impératifs du langage :

Classes abstraites, interfaces, classes internes, classes anonymes,
méthodes, passage de paramètres,
instructions, exceptions, assertions

3.  13/10/15 Interfaces, plusieurs Classes, introduction au "Design Pattern"

Héritage, liaison dynamique, paquetages,
les patrons Adaptateur et Procuration

4.1 20/10/15 Quelques Patrons et programmation évènementielle

Patrons Observateur/Observé, Stratégie, Composite
Modèle Vue Contrôleur, MVC
Usage des classes internes, anonymes et des adaptateurs

4.2 20/10/15 Swing (uniquement les transparents 56 à 72)

IHM, JApplet, MVC

5-1.27/10/15 Collections

Les Collections : traitement de manière uniforme de tous les agrégats d'éléments
Quelques patrons : Itérator, Template Method et Fabrique Method

5-2.03/11/15 néricité et synthèse des premiers cours

Généricité : vers un typage plus rigoureux.

6.-1 10/11/15 Structures de données et Patterns de conception

Les patrons : Composite, Visiteur, Interpréteur ,.. ...

6.-2  17/11/15 Patterns de conception suite

Les patrons : Memento, Command, Template Method, Command. ...

7.    24/11/15 Introspection et réflexivité en Java

Typage dynamique, introduction aux  Java Beans, l'outil BeanBox, les patrons Visiteur et Procuration avec introspection

8.-1  01/12/15 Patterns de conception

Le patron Décorateur : Pré,Post assertions, invariant de classe,

8.-2  8/12/15 Programmation des Entrées/Sorties et synthèse des cours précédents

            Les  entrées/sorties, persistance d'un objet, l'API I/O, le patron DAO

9.   15/12/15 XML et JAVA

Persistance en XML avec SAX et JDOM

10.   05/01/16 Injection de dépendance

A la recherche du couplage faible, par une séparation de la configuration et de l'utilisation

11.   12/01/16 Programmation Concurrente

La classe Thread, l'instruction synchronized, la classe Object revisitée

12.   19/01/16  Révisions  et/ou La machine Virtuelle Java (JVM)

Architecture, jeu d'instructions, WhileL : le couple Composite/Visiteur appliqué à la génération de code

 

--------------------------------------------------

 

13.   20/01/16 Révisions

Fonction d'abstraction, invariant de représentation (cf. Liskov), Pré-Post assertions, invariant de classe, héritage d'assertions, JASS, COFOJA

 

--------------------------------------------------

 

 

12  21/01/2014 Programmation par Contrats ou séance de révisions (la dernière séance)

 

11.  xx/xx/13  La machine Virtuelle Java

Architecture, jeu d'instructions, WhileL : le couple Composite/Visiteur appliqué à la génération de code

12-1  xx/xx/13  Programmation Concurrente

La classe Thread, l'instruction synchronized

12-2  xx/xx/13  Programmation Concurrente

java.util.concurrent en cours d'élaboration

 

13  xx/xx/13 Séance de révisions,  Dernière séance

 



 

 

 

Prévisionnel ... 2013

 

13  15/01/13  Programmation Concurrente

Les variables conditions, les méthodes wait et notify, le patron Singleton revisité

14  22/01/13  Programmation par contrats

11.   Expressions Régulières

la méthode split, la classe Scanner, les opérateurs avides, réticents et possessifs

14 Révisions en Web Conférence

Parcours des patrons vus en cours et/ou en ED, échantillon de questions ...



 

Une suite Java possible au Cnam :

 

 

 

 

 

 

Programme prévisionnel
 


 

 

xx  Programmation Concurrente

Serveurs au protocole TCP

xx  Programmation par contrats

Pré et post assertions, héritage, usage de Jass et jass-modern (annotations), syntaxe JML

1x. OCL.
         Tranparents : 1 par feuille , 2 par feuille

1x. Expressions Régulières.
         Tranparents : 1 par feuille , 2 par feuille , 3 par feuille , 4 par feuille , 6 par feuille

xx.  JVM (Java Virtual Machine)

xx.   Révisions

xx  MVC, IHM et swing

MVC
IHM Swing, JApplet

 

 

 

Programme et supports de cours NFP121 2009-2010


1. Structure des applications objets avec JAVA et UML :
       transparents : 1/page , 2/page , 3/page

packages, classes, instances,
visibilité, héritage,
spécialisation, surcharge

2. Types primitifs, Aspects impératifs du langage :
          Tranparents : 1 par feuille , 2 par feuille , 3 par feuille , 4 par feuille , 6 par feuille , pas de nouveaux exercices proposés (cf. 1)

Sémantique de l'égalité,
méthodes, passage de paramètres,
instructions, exceptions

3. Assert, Interfaces, Types et Classes
         Tranparents : 1 par feuille , 2 par feuille , 3 par feuille , 4 par feuille , 6 par feuille

assert,
introduction aux structures de données récursives,
classes abstraites, interfaces, classes internes, classes anonymes.

4. Programmation évènementielle
         Tranparents : 1 par feuille , 2 par feuille , 3 par feuille , 4 par feuille , 6 par feuille

Pattern Observateur/Observé
IHM Awt et Swing,
application des classes internes, anonymes et des adapteurs

5. Généricité et Collections:
         Tranparents : 1 par feuille , 2 par feuille , 3 par feuille , 4 par feuille , 6 par feuille
         un petit QUIZ sur la généricité JAVA depuis 1.5

Les Collections : traiter de manière uniforme tous les agrégats d'éléments
Généricité : typage plus rigoureux

6. Structures de données et Patterns de conception
         Tranparents : 1 par feuille , 2 par feuille , 3 par feuille , 4 par feuille , 6 par feuille

Les patterns : composite, itérateur, visiteur, ...

7. Introspection et réflexivité en Java:
         Tranparents : 1 par feuille , 2 par feuille , 3 par feuille , 4 par feuille , 6 par feuille

typage dynamique, Atelier Java Beans

8. Programmation des Entrées/Sorties:
         Tranparents : 1 par feuille , 2 par feuille , 3 par feuille , 4 par feuille , 6 par feuille

 les Apis I/O et le Pattern Décorateur

9. XML et JAVA :
         Tranparents : 1 par feuille , 2 par feuille , 3 par feuille , 4 par feuille , 6 par feuille

SAX et JDOM

10. JVM (Java Virtual Machine)
         Tranparents : 1 par feuille , 2 par feuille , 3 par feuille , 4 par feuille , 6 par feuille

11. Programmation concurrente.
         Tranparents : 1 par feuille , 2 par feuille , 3 par feuille , 4 par feuille , 6 par feuille

12. OCL.
         Tranparents : 1 par feuille , 2 par feuille

13. Expressions Régulières.
         Tranparents : 1 par feuille , 2 par feuille , 3 par feuille , 4 par feuille , 6 par feuille

xx. Et ensuite  : ...