Documente Academic
Documente Profesional
Documente Cultură
Etudiant en Master I
1. Définition : ................................................................................................................................... 5
a. Acteur ...................................................................................................................................... 6
1. Définition : ................................................................................................................................. 13
1. Définition : ................................................................................................................................. 22
2
Le Langage UML W.Moumouni
1. Définitions : ........................................................................................................................... 22
2. Représentation: ..................................................................................................................... 22
1. Définition ................................................................................................................................... 24
Conclusion ............................................................................................................................................. 27
3
Le Langage UML W.Moumouni
Introduction
Le langage UML est un langage de modélisation utilisé dans plusieurs domaines y compris
l’informatique précisément dans la POO (Programmation Orientée Objet). En tant que
étudiant informaticien développeur il est primordial de maitriser ce langage pour mieux
effectuer une approche concrète et claire des applications à développer. C’est dans cette
logique que cette formation sur UML a été effectuée. La version étudiée dans ce document
est UML 2.0.
Définitions :
Ce langage est dans sa version UML 2.0 qui comporte 13 diagrammes par rapport à la version
UML 1.0 qui ne compte que 9 diagrammes.
Diagramme d’activité
Diagramme de classes
Diagramme de communication
Diagramme de composants
Diagramme de déploiement
Diagramme d’états-transitions
4
Le Langage UML W.Moumouni
Diagramme d’objets
Diagramme de temps
Diagramme de séquence
Tous ces diagrammes ne sont pas utilisé en même temps lors d’une modélisation puisque chaque
diagramme à un rôle bien spécifique et selon le besoin.
D’ailleurs nous allons étudier que trois parmi ces quatre diagrammes, qui sont :
Diagramme de séquence
Diagramme d’état-transition
Diagramme de classes
2. Les objectifs :
Les objectifs de ce diagramme sont tout à fait évidents :
a. Acteur
Un acteur est l’idéalisation d’un rôle joué par une personne, un système externe ou un dispositif
matériel qui interagit avec le système. Ainsi nous avons des acteurs principaux qui sont les principaux
utilisateurs, et des acteurs secondaires ce qui par exemple ferons marcher le système exemple
l’administrateur etc. Le statu d’un acteur va dépendre des fonctionnalités du système utilisés par
celui-ci.
Il se représente par un petit bonhomme (figure 1) avec son nom (exemple son rôle) inscrit en
dessous.
Cl i ent
Il est également possible de représenter un acteur sous la forme d’un classeur (figure 2) stéréotypé.
<<acteur>>
Client
Figure 2 : Exemple de représentation d’un acteur sous forme de classeur
Le stéréotype : Un stéréotype est une annotation s’appliquant sur un élément de modèle, exemple le
stéréotype <<acteur>> au niveau du classeur .Précisons que le stéréotype n’est pas propre au
diagramme de cas d’utilisation mais est une annotation générale utilisable dans tous les diagrammes
UML.
b. Cas d’utilisation
Un cas d’utilisation est une unité représentant une fonctionnalité visible de l’extérieur, réalisant un
service de bout en bout, avec un déclenchement, un déroulement et une fin, pour l’acteur qui l’initie.
Un cas d’utilisation modélise donc un service rendu par le système, sans imposer le mode de
réalisation de ce service. Il est représenté par une ellipse (figure 3) contenant le nom du cas (un
verbe à l’infinitif), et optionnellement, au-dessus du nom, un stéréotype.
<<Stéréotype>>
Nom du cas
6
Le Langage UML W.Moumouni
Figure 4: Diagramme de cas d’utilisation modélisant une borne d’accès à une banque.
7
Le Langage UML W.Moumouni
Acteurs principaux et secondaires :
Un acteur est qualifié de principal pour un cas d’utilisation lorsque ce cas rend service à
cet acteur.
Les autres acteurs sont alors qualifiés de secondaires. Un cas d’utilisation a au plus un
acteur principal. Un acteur principal obtient un résultat observable du système tandis
qu’un acteur secondaire est sollicité pour des informations complémentaires.
En général, l’acteur principal initie le cas d’utilisation par ses sollicitations.
Le stéréotype << primary >> vient orner l’association reliant un cas d’utilisation à son
acteur principal, le stéréotype << secondary >> est utilisé pour les acteurs secondaires.
Lorsqu’un cas d’utilisation n’est relié à aucun acteur, c’est cas d’utilisation interne.
Types et représentations
Figure 6 : Exemple de diagramme avec des relations entre les cas d’utilisations
8
Le Langage UML W.Moumouni
Il existe principalement deux types de relations :
les dépendances stéréotypées, qui sont explicitées par un stéréotype (les plus
utilisés sont l’inclusion et l’extension),
et la généralisation/spécialisation.
Une dépendance se représente par une flèche avec un trait pointillé (figure 6). Si le cas A
inclut ou étend le cas B, la flèche est dirigée de A vers B.
Le symbole utilisé pour la généralisation est une flèche avec un trait plein dont la pointe
est un triangle fermé désignant le cas le plus général (figure 6).
Relation d’inclusion
Relation d’extension
La relation d’extension est probablement la plus utile car elle a une sémantique qui a un
sens du point de vue métier au contraire des deux autres qui sont plus des artifices
d’informaticiens.
On dit qu’un cas d’utilisation A étend un cas d’utilisation B lorsque le cas d’utilisation A
peut être appelé au cours de l’exécution du cas d’utilisation B. Exécuter B peut
éventuellement entraîner l’exécution de A : contrairement à l’inclusion, l’extension est
optionnelle. Cette dépendance est symbolisée par le stéréotype << extend >> (figure 6).
L’extension peut intervenir à un point précis du cas étendu. Ce point s’appelle le point
d’extension. Il porte un nom, qui figure dans un compartiment du cas étendu sous la
rubrique point d’extension, et est éventuellement associé à une contrainte indiquant le
moment où l’extension intervient. Une extension est souvent soumise à condition.
Graphiquement, la condition est exprimée sous la forme d’une note. La figure 6 présente
l’exemple d’une banque où la vérification du solde du compte n’intervient que si la
demande de retrait dépasse 20 euros.
9
Le Langage UML W.Moumouni
Relation de généralisation
La seule relation possible entre deux acteurs est la généralisation : un acteur A est une
généralisation d’un acteur B (spécialisation) si l’acteur A peut être substitué par l’acteur
B. Dans ce cas, tous les cas d’utilisation accessibles à A le sont aussi à B, mais l’inverse
n’est pas vrai. Ceci ressemble au concept d’héritage en POO.
Le symbole utilisé pour la généralisation entre acteurs est une flèche avec un trait plein
dont la pointe est un triangle fermé désignant l’acteur le plus général (on a déjà vu ça
avec les relations entre cas d’utilisation).
Par exemple, la figure 7 montre que le directeur des ventes est un préposé aux
commandes avec un pouvoir supplémentaire : en plus de pouvoir passer et suivre une
commande, il peut gérer le stock. Par contre, le préposé aux commandes ne peut pas
gérer le stock.
10
Le Langage UML W.Moumouni
5. Exemple d’application
Nous allons mettre en pratique les différentes notions acquises concernant les
diagrammes de cas d’utilisation, dans l’étude de cas suivant :
S’inscrire
S’authentifier
Gérer le panier
Commander le livre
Payer
Maintenance catalogue
Maintenance du site
Les Acteurs :
11
Le Langage UML W.Moumouni
12
Le Langage UML W.Moumouni
2. Les objectifs :
Elle a comme objectifs de présenter :
Une ligne de vie se représente par un rectangle, auquel est accrochée une ligne verticale
pointillée, contenant une étiquette dont la syntaxe est :
[<nom_du_rôle>] : [<Nom_du_type>]
Au moins un des deux noms doit être spécifié dans l’étiquette, les deux points (:) sont,
quand à eux, obligatoire.
Un message définit une communication particulière entre des lignes de vie. Plusieurs types de
messages existent, les plus communs sont :
13
Le Langage UML W.Moumouni
Messages asynchrones
Messages synchrones
La création d’un objet est matérialisée par une flèche qui pointe sur le sommet d’une
ligne de vie (figure 11).
La destruction d’un objet est matérialisée par une croix qui marque la fin de la ligne de
vie de l’objet (figure 11). La destruction d’un objet n’est pas nécessairement consécutive
à la réception d’un message.
14
Le Langage UML W.Moumouni
Événements et messages
UML permet de séparer clairement l’envoi du message, sa réception, ainsi que le début
de l’exécution de la réaction et sa fin (figure 12).
Dans la plupart des cas, la réception d’un message est suivie de l’exécution d’une
méthode d’une classe. Cette méthode peut recevoir des arguments et la syntaxe des
messages permet de transmettre ces arguments.
15
Le Langage UML W.Moumouni
La syntaxe de réponse à un message est la suivante :
Un message complet est tel que les événements d’envoi et de réception sont connus.
Un message perdu est tel que l’événement d’envoi est connu, mais pas l’événement de
réception. Il se représente par une flèche qui pointe sur une petite boule noire
(figure 14).
Un message trouvé est tel que l’événement de réception est connu, mais pas l’événement
d’émission. Une flèche partant d’une petite boule noire représente un message trouvé
(figure 14).
Un fragment combiné représente des articulations d’interactions. Il est défini par un opérateur
et des opérandes. L’opérateur défini la signification du fragment combiné.
Il existe 12 d’opérateurs définis dans la notation UML 2.0.
Il est représenté dans un rectangle dont le coin supérieur gauche contient un pentagone. Dans
le pentagone figure le type de la combinaison, appelé opérateur d’interaction. Les opérandes
d’un opérateur d’interaction sont séparés par une ligne pointillée. Les conditions de choix des
opérandes sont données par des expressions booléennes entre crochets ([ ]).
16
Le Langage UML W.Moumouni
Opérateur alt
Figure 15: Représentation d’un choix dans un diagramme de séquence illustrant le découvrement d’une case au
jeu du démineur.
Opérateurs opt
L’opérateur option, ou opt, comporte une opérande et une condition de garde associée. Le
sous-fragment s’exécute si la condition de garde est vraie et ne s’exécute pas dans le cas
contraire.
Opérateur loop
17
Le Langage UML W.Moumouni
La condition de garde est placée entre crochets sur la ligne de vie. La boucle est répétée
au moins minInt fois avant qu’une éventuelle condition de garde booléenne ne soit
testée. Tant que la condition est vraie, la boucle continue, au plus maxInt fois. Cette
syntaxe peut être remplacée par une indication intelligible comme sur la figure 15.
18
Le Langage UML W.Moumouni
4. Exemple d’application
Nous allons donner des exemples de diagramme de séquence, pour l’étude de cas
1 du chapitre 1.
Ainsi chaque diagramme de séquence est lié à un cas d’utilisation du diagramme
de cas d’utilisation.
19
Le Langage UML W.Moumouni
2. Les objectifs :
Décrire les changements d'états d'un objet ou d'un composant
1. Définitions :
Un état se caractérise par sa durée et sa stabilité, il représente une conjonction instantanée des
valeurs des attributs d'un objet.
Une transition est déclenchée par un événement. En d'autres termes : c'est l'arrivée d'un
événement qui conditionne la transition.
Les transitions peuvent aussi être automatiques, lorsqu'on ne spécifie pas l'événement qui la
déclenche.
2. Représentation:
Etat simple :
Etat initial :
Etat final :
22
Le Langage UML W.Moumouni
23
Le Langage UML W.Moumouni
2. Les objectifs :
Modéliser les concepts du domaine d’application
a. Les Classes
Une classe est la description formelle d’un ensemble d’objets ayant une sémantique et
des caractéristiques communes.
Les classes sont les modules de base de la programmation orientée objet.
Une classe est représentée en utilisant un rectangle divisé (figure) en trois sections :
La section supérieure est le nom de la classe.
La section centrale définit les propriétés de la classe.
La section du bas énumère les méthodes de la classe.
24
Le Langage UML W.Moumouni
b. Les Relations
Association :
Une association est une relation générique entre deux classes. Elle est modélisée
par une ligne (figure) reliant les deux classes. Cette ligne peut être qualifiée avec
le type de relation, et peut également comporter des règles de multiplicité (par
exemple un à un, un à plusieurs, plusieurs à plusieurs) pour la relation.
Personne Adresses
0..*
1
Composition
Si une classe ne peut pas exister par elle-même, mais doit être un membre d'une autre
classe, alors elle possède une relation de composition avec la classe contenant.
Une relation de composition est indiquée par une ligne avec un "losange" (figure)
rempli.
Voiture Roue
1
0..4
Agrégation
Les agrégations indiquent une relation de contenant-contenu. Elle décrite par une
relation "possède".
Une relation d'agrégation est représentée par une ligne avec un "losange" creux.
Bibliothèque Livre
1..*
1..1
Généralisation
Une relation de généralisation est l'équivalent d'une relation d'héritage en terme
orientés objet (relation "est-un "). Une relation de généralisation est indiquée par une
flèche creuse se dirigeant vers la classe "Parent ".
25
Le Langage UML W.Moumouni
Annimal
Chat Vache
Dépendance
Quand une classe utilise une autre classe, par exemple comme membre ou comme
paramètre d'une de ces fonctions, elle "dépend" ainsi de cette classe.
Une relation de dépendance est représentée par une flèche pointillée.
4. Exemple d’application
Nous allons donner le diagramme de classe, pour l’étude de cas 1 du chapitre 1.
Les différentes méthodes n’on pas été présenter dans ce diagramme pour éviter
de surcharger celui-ci.
26
Le Langage UML W.Moumouni
Panier Ligne
1..*
1..*
Auteur
Adresse - Nom : String
- adresse : String - Prenom : String
Editeur
- Nom : String
- Pays : String
0..*
0..*
Commande
Carte bancaire
- NumCmde : int
1..1 - dateCmde : Date 0..1
- montantCmde : double 0..*
- dateLivraison : Date
Conclusion
Cette étude nous a permis de se familiariser et s'initier au langage UML.
Ainsi nous avons acquis différentes notions concernant les diagrammes de cas
d’utilisation, de séquence, d’état-transition et de classe. Personnellement cette étude m’a
été bénéfique et pour une bonne maitrise des différentes notions acquises, il est
nécessaire de faire beaucoup d’étude de cas pratique. Cette étude a suscité en moi une
curiosité d’aller comprendre les autres diagrammes que nous n’avons pas abordé à
augmenté. En somme ce langage propose plusieurs types de diagramme qui ne sont pas
tous utilisé lors de la conception d’une application. Ce qui nous oblige à bien choisir le
type de diagramme qui va mieux expliquer notre application.
27