développeurs développeurs

Xavier Blanc
Isabelle Mounier
avec la contribution de Cédric Besse
UML2
pour les
développeurs
Cours avec exercices corrigés
UML2
pour les
développeurs
Cours avec exercices corrigés
Un cours d’initiation à UML conçu pour les développeurs et les étudiants en informatique
La plupart des livres sur UML s’adressent avant tout aux concepteurs et architectes logiciels, selon une démarche «tout-modèle»
dans laquelle la production de code est traitée comme une activité subalterne. Cette approche suscite évidemment des réticences
chez les développeurs et déconcerte les étudiants, dont la formation reste axée principalement sur la programmation et qui mesu-
rent mal les enjeux du formalisme UML.
UML 2 pour les développeurs prend le contre-pied de ces approches classiques. L’ouvrage montre comment articuler harmonieu-
sement modélisation et programmation, en insistant sur les gains de productivité que permettent ces allers-retours entre les
modèles UML et le code.
Chaque notion UML importante est introduite par un exemple et chaque chapitre se clôt par une série d’exercices corrigés (90
au total), qui permettront au lecteur de tester ses connaissances.
Pour illustrer concrètement les relations entre code et modèles, les auteurs font le choix du langage Java, les principes présen-
tés étant naturellement transposables à d’autres langages.
Au sommaire
Pourquoi modéliser • Diagrammes de classes • Reverse Engineering • Rétroconception et patrons de conception (design patterns)
• Génération de code • Diagrammes de séquence • Diagrammes de séquence de test • Plates-formes d’exécution • Diagrammes
de cas d’utilisation • Développement avec UML • Corrigés des exercices.
Sur le site www.editions-eyrolles.com
•Dialoguez avec les auteurs
•Téléchargez les modèles et le code source des exemples du livre
9 7 8 2 2 1 2 1 2 0 2 9 5
Code éditeur : G12029 • ISBN : 2-212-12029-X
16,90 €
X. Blanc I. Mounier
Xavier Blanc
Maître de conférences à l’Université Pierre et Marie Curie (Paris 6), Xavier Blanc est responsable de l’enseigne-
ment des techniques de modélisation en 3eannée de licence et en master d’informatique. Ses recherches portent
depuis 1998 sur l’ingénierie guidée par les modèles et il est le représentant du LIP6 (Laboratoire d’informatique
de l’Université Paris 6) à l’OMG. Il est également auteur de MDA en action, paru chez le même éditeur.
Isabelle Mounier
Maître de conférences à l’Université Pierre et Marie Curie, Isabelle Mounier enseigne principalement les tech-
niques de développement d’applications en licence d’informatique. Ses activités de recherche ont d’abord porté
sur la vérification de propriétés temporelles de systèmes informatiques modélisés par des réseaux de Petri et
elle s’intéresse aujourd’hui aux aspects formels des langages de modélisation tels qu’UML.
UML2
pour les développeurs
blanc 11/09/06 21:07 Page 1
© Groupe Eyrolles 2006,
ISBN : 2-212-12029-X

Table des matières
Préface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . III
Remerciements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . V
Avant-propos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . VII
Une approche à contre-pied . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . VIII
Organisation de ce cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . VIII
À qui s’adresse ce cours ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . IX
CHAPITRE 1
Un curieux besoin de modèles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Construction d’applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Le code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Les modèles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
CHAPITRE 2
Diagrammes de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Vue structurelle du modèle UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Paradigme orienté objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Concepts élémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Associations entre classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Concepts avancés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
CHAPITRE 3
Reverse Engineering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Sémantiques UML et Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Différences des sémantiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

UML pour les développeurs
XII
Synthèse entre UML et les langages de programmation . . . . . . . . . . . . . . . 30
Passage de code Java vers les diagrammes de classes . . . . . . . . . . . . . . 30
Règles de correspondance du Reverse Engineering . . . . . . . . . . . . . . . . . . 32
Intérêt et limites du Reverse Engineering . . . . . . . . . . . . . . . . . . . . . . . . 34
Diagrammes à faire après un Reverse Engineering . . . . . . . . . . . . . . . . . . . 35
CHAPITRE 4
Rétroconception et patrons de conception . . . . . . . . . . . . . . . . . . 39
Identification des dépendances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Qu’est-ce qu’une dépendance ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Impact des cycles de dépendances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Casser les cycles de dépendances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Patron de conception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Le patron de conception Observer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
CHAPITRE 5
Génération de code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
D’UML à Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
UML vers Java et Java vers UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
Approches UML et code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Cycle de développement UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
CHAPITRE 6
Diagrammes de séquence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Vue comportementale du modèle UML . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Concepts élémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Le temps dans les diagrammes de séquence . . . . . . . . . . . . . . . . . . . . . . . . 66
Liens avec la vue structurelle du modèle . . . . . . . . . . . . . . . . . . . . . . . . . 68
Objet et classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
Diagramme et modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Concepts avancés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
Interactions et génération de code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
Fragment d’interaction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Limites intrinsèques des interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

Table des matières XIII
CHAPITRE 7
Diagrammes de séquence de test . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Les tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Comment utiliser les tests ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
Écriture de cas de test à partir d’un modèle UML . . . . . . . . . . . . . . . . . 80
Cas de test abstrait et interaction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Cas de test exécutables et interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
CHAPITRE 8
Plates-formes d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Java dans UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Modèles 100 % UML et modèles UML pour Java . . . . . . . . . . . . . . . . . . . 87
UML productif ou pérenne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Niveaux conceptuel et physique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Abstraction de la plate-forme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Niveaux d’abstraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Cycle de développement UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Intégration des deux niveaux dans le cycle . . . . . . . . . . . . . . . . . . . . . . . . . 92
Approches possibles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
CHAPITRE 9
Diagrammes de cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Vue fonctionnelle du modèle UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Fonctionnalités d’une application orientée objet . . . . . . . . . . . . . . . . . . . . . 97
Concepts élémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Liens avec les autres parties du modèle . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Concepts avancés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
Concepts avancés relatifs aux cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . 101
Concept avancé relatif aux acteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
CHAPITRE 10
Développement avec UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Analyse et conception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Analyse du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Conception de la solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

UML pour les développeurs
XIV
Comment passer du quoi au comment ? . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Méthode de développement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
La méthode « UML pour le développeur » . . . . . . . . . . . . . . . . . . . . . . . . . 115
CHAPITRE 11
Corrigés des TD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
TD1. Un curieux besoin de modélisation . . . . . . . . . . . . . . . . . . . . . . . . . 123
TD2. Diagrammes de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
TD3. Reverse Engineering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
TD4. Rétroconception et patrons de conception . . . . . . . . . . . . . . . . . . . 141
TD5. Génération de code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
TD6. Diagrammes de séquence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
TD7. Diagrammes de séquence de test . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
TD8. Plates-formes d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
TD9. Diagrammes de cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
TD10. Développement avec UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
ANNEXE 1
Code d’un carnet d’adresses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
ANNEXE 2
Exemple de partiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
Questions de cours (4 points) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
Exercices (16 points) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201