support - Berdjugin

INF250 Programmation
Travaux dirigés et travaux pratiques
d'algorithmique du deuxième semestre
Jean-François Remm
Jean-François Berdjugin
Vincent Lestideau

INF250 Programmation: Travaux dirigés et travaux pratiques d'al-
gorithmique du deuxième semestre
par Jean-François Remm, Jean-François Berdjugin, et Vincent Lestideau

iii
Table des matières
Présentation et objectifs ................................................................................................................ vi
1. Travaux dirigés ......................................................................................................................... 1
1. Classes/Association Les bases .............................................................................................. 1
1.1. Cours et exemples ................................................................................................... 1
1.1.1. La classe ..................................................................................................... 1
1.1.2. L'association ................................................................................................ 2
1.1.3. Les multiplicités ........................................................................................... 3
1.1.4. L'agrégation ................................................................................................. 3
1.1.5. La composition ............................................................................................ 4
1.2. Exercices ............................................................................................................... 4
1.2.1. Diagramme de classe d'une maison .................................................................. 4
1.2.2. La voiture ................................................................................................... 4
2. Classes/Association Le détail (Facultatif) ............................................................................... 4
2.1. Cours et exemples ................................................................................................... 4
2.1.1. Les stéréotypes d'association .......................................................................... 4
2.1.2. Les classes internes ...................................................................................... 5
2.2. Exercices ............................................................................................................... 6
2.2.1. stéréotype d'association .................................................................................. 6
2.2.2. Classe interne .............................................................................................. 6
3. Héritage - classes abstraites - interface - polymorphisme ........................................................... 6
3.1. Cours et exemples ................................................................................................... 6
3.1.1. Héritage ...................................................................................................... 6
3.1.2. Classe abstraite ............................................................................................ 8
3.1.3. Interface ..................................................................................................... 8
3.1.4. Polymorphisme ............................................................................................ 9
3.2. Exercices ............................................................................................................. 10
3.2.1. Diagramme de classe UML .......................................................................... 12
3.2.2. Syntaxe et visibilité ..................................................................................... 12
3.2.3. Classe et interface ....................................................................................... 12
3.2.4. Création d'objets ......................................................................................... 12
3.2.5. Exécution de code ...................................................................................... 12
3.2.6. Surcharge redéfinition .................................................................................. 13
3.2.7. Exécution de code ...................................................................................... 13
3.2.8. Utilisation d'une interface ............................................................................. 13
3.2.9. Polymorphisme ........................................................................................... 13
3.2.10. Polymorphisme ......................................................................................... 13
2. Travaux pratiques .................................................................................................................... 15
1. Introduction à la programmation ......................................................................................... 15
1.1. Communication entre objets .................................................................................... 15
1.1.1. Les classes d'origine .................................................................................... 15
1.1.2. Association simple ...................................................................................... 16
1.1.3. Agrégation (partagée) .................................................................................. 17
1.1.4. La composition ........................................................................................... 18
1.2. Héritage, classe abstraite et interface ......................................................................... 20
1.2.1. Héritage .................................................................................................... 20
1.2.2. Classe abstraite et interface ........................................................................... 21
1.2.3. Polymorphisme ........................................................................................... 22
1.3. Swing ................................................................................................................. 23
1.3.1. Introduction ............................................................................................... 25
1.3.2. Réalisations ............................................................................................... 27
1.4. Evénements .......................................................................................................... 31
1.4.1. Complément : les classes internes .................................................................. 31
1.4.2. Architecture des classes ............................................................................... 32
1.4.3. Tri des diérents Events ................................................................................ 36
1.4.4. Réalisations ............................................................................................... 36

INF250 Programmation
iv
1.5. Dessiner en java, afficher des images et jouer un son ................................................... 39

v
Liste des illustrations
1.1. Classe vide ............................................................................................................................ 1
1.2. Classe avec trois compartiments ................................................................................................ 2
1.3. Association simple .................................................................................................................. 2
1.4. Association avec multiplicité .................................................................................................... 3
1.5. Agrégation ............................................................................................................................. 3
1.6. Composition .......................................................................................................................... 4
1.7. Stéréotypes d'association .......................................................................................................... 5
1.8. Classes imbriquées .................................................................................................................. 5
1.9. Héritage ................................................................................................................................ 6
1.10. Chaînage des constructeurs ..................................................................................................... 7
1.11. Classe Abstraite .................................................................................................................... 8
1.12. Interface .............................................................................................................................. 9
1.13. Polymorphisme ................................................................................................................... 10
2.1. Classe isolées ....................................................................................................................... 16
2.2. Association simple ................................................................................................................ 17
2.3. Agrégation partagée ............................................................................................................... 18
2.4. Agrégation de composition ..................................................................................................... 19
2.5. Diagramme de classe complet ................................................................................................. 20
2.6. Arbre d'héritage .................................................................................................................... 21
2.7. Interface .............................................................................................................................. 22
2.8. Structure d'une JFrame ........................................................................................................... 24
2.9. Méthodologie (imbrications) .................................................................................................... 24
2.10. IHM1 ................................................................................................................................ 25
2.11. IHM2 ................................................................................................................................ 26
2.12. Essai de Frame ................................................................................................................... 27
2.13. BorderLayout et JButton ....................................................................................................... 28
2.14. BorderLayout et d'autres Components ..................................................................................... 28
2.15. GridLayout ......................................................................................................................... 29
2.16. BorderLayout avec DEUX JPanels ......................................................................................... 29
2.17. JFrame à reproduire ............................................................................................................. 30
2.18. Découpage de la JFrame en Panels ......................................................................................... 31
2.19. Dépendance entre instances ................................................................................................... 32
2.20. Base IHM/Traitement ........................................................................................................... 33
2.21. Classe interne ..................................................................................................................... 34
2.22. Délégation .......................................................................................................................... 35
2.23. Une action sur un bouton avec une classe externe ...................................................................... 36
2.24. Une action sur deux boutons avec une classe externe ................................................................. 36
2.25. ne action sur deux boutons avec une classe interne .................................................................... 37
2.26. Une action sur deux boutons en implémentant directement l'interface ............................................ 37
2.27. Semestre ............................................................................................................................ 38
2.28. TestJFrame ......................................................................................................................... 41