Votre progression

Continuez pour débloquer la suite !
0 / 0 étapes complétées 0
%

Syllabus

  1. Description

  2. Objectifs

  3. Validations de compétences

  4. Public cible

    Aucun public cible spécifié pour ce module.

  5. Besoins techniques

  6. Prérequis

    • Aucun prérequis
  7. Niveau

  8. Historique du module

    Aucune action enregistrée

UML : modéliser un système avant de le coder

Lire et produire les diagrammes UML utiles à un projet : cas d’utilisation pour le besoin, classes pour la structure, séquence pour les échanges. Un diagramme qui ne répond pas à une question précise est un dessin, pas un modèle.

À la fin du cours

  • Dire ce qu’UML modélise et ce qu’il ne modélise pas.
  • Distinguer classe, instance, attribut et méthode.
  • Choisir la bonne relation : composition, agrégation, généralisation.
  • Lire un diagramme de cas d’utilisation, include et extend compris.
  • Éviter les cinq erreurs qui rendent un diagramme inutilisable.

Organisation

Le cours part de ce qu’un modèle sert vraiment, puis traverse classes, relations, cas d’utilisation et erreurs à éviter.

Prérequis : Savoir décrire un besoin en une phrase et lire un schéma.

À quoi sert un modèle

UML est un langage de modélisation graphique normalisé. Il propose des diagrammes standardisés pour représenter la structure, le comportement et les échanges d’un système. Il sert de langage commun entre membres d’une équipe : deux personnes qui n’ont pas le même vocabulaire peuvent pointer le même schéma et se comprendre.

Son intérêt principal est le coût de la correction. Une erreur de conception trouvée sur un diagramme coûte quelques minutes ; la même erreur trouvée en production coûte une reprise de code, une migration de données et une perte de confiance du client.

UML ne modélise pas tout : il ne décrit ni l’organisation des fichiers, ni les choix de bibliothèques, ni la performance. Un modèle qui prétend tout dire devient illisible et n’est plus lu.

Un diagramme doit répondre à UNE question. « Que fait le système pour qui ? » appelle un diagramme de cas d’utilisation. « De quelles données dépend cette classe ? » appelle un diagramme de classes. « Dans quel ordre les objets se parlent-ils ? » appelle un diagramme de séquence.

Point de contrôle : Je dis à quelle question répond chaque diagramme avant de le dessiner.

Classe, instance, attribut, méthode

Une classe est une catégorie d’objets : elle décrit une structure et un comportement partagés. Une instance est un objet concret de cette classe. La classe « Étudiant » décrit la catégorie ; « Alice, 21 ans » est une instance.

Un attribut est une donnée portée par la classe, avec un type et éventuellement une contrainte. Une méthode est une opération que les instances savent effectuer. La visibilité (publique, protégée, privée) indique qui a le droit d’y accéder.

La cardinalité précise combien d’instances participent à une relation : 1, 0..1, 1..*, *. Oublier la cardinalité est la première cause d’ambiguïté dans un modèle de données.

Étudiant
  - matricule : chaîne
  - nom : chaîne
  - âge : entier entre 18 et 65
  - notes[0..*] : réel
  + calculerMoyenne() : réel
  + ajouterNote(valeur : réel) : void
Notation Signification Exemple
+nom Attribut ou méthode public +calculerMoyenne()
-nom Privé, accessible seulement dans la classe -notes[0..*]
#nom Protégé, accessible aux classes filles #matricule
1..* Au moins une instance obligatoire Un cours a 1..* inscrits
0..1 Au plus une instance, optionnelle Un étudiant a 0..1 stage
graph TD C["Classe Étudiant"] -->|instancie| A["Alice, 21 ans"] C -->|porte| AT["Attributs : nom, âge, notes"] C -->|expose| M["Méthodes : calculerMoyenne()"]
Point de contrôle : Je distingue la classe de l’instance, et je sais écrire une cardinalité.

Composition, agrégation, généralisation

Le choix de la relation porte du sens. Confondre composition et agrégation fait croire à une contrainte de vie qui n’existe pas, et mène à du code qui supprime ce qui doit survivre.

La composition est une relation forte : le tout détruit ses parties. Une commande et ses lignes de commande : supprimer la commande supprime les lignes. L’agrégation est plus faible : le contenant référence des éléments qui ont leur proprecycle de vie. Une équipe et ses membres : dissoudre l’équipe ne supprime pas les personnes.

La généralisation est une relation d’héritage entre catégories : une classe fille est une classe mère. Une association réflexive relie une classe à elle-même, comme un employé et son responsable. Une association ternaire relie trois classes, par exemple étudiant, cours et enseignant pour une session.

Relation Force Cycle de vie des parties Exemple
Composition Forte Lié au tout : supprimé avec lui Commande → lignes de commande
Agrégation Faible Indépendant du contenant Équipe → membres
Généralisation Héritage La classe fille est une classe mère Personne → Étudiant, Enseignant
Réflexive Variable Une classe liée à elle-même Employé → responsable
graph TD CMD[Commande] -->|composition| LIG[Lignes de commande] EQP[Équipe] -->|agrégation| MEM[Membres] P[Personne] -->|généralisation| ETU[Étudiant] P -->|généralisation| ENS[Enseignant]

L’erreur la plus fréquente dans les modèles d’étudiants : écrire que « la classe Étudiant est composée d’instances de la classe Cours ». C’est l’inverse — un étudiant s’inscrit à des cours, il ne les contient pas. Une composition se lit dans le sens : si je supprime le tout, la partie disparaît-elle ?

Point de contrôle : Je justifie le choix d’une composition plutôt qu’une agrégation par le cycle de vie.

Diagramme de cas d’utilisation

Un acteur est un rôle joué par une personne ou un système externe qui interagit avec le système modélisé. Il se dessine par une figure en bâton ou une boîte étiquetée. Le cas d’utilisation est une fonctionnalité que le système offre pour satisfaire un acteur : il se dessine par une ellipse.

La liaison entre l’acteur et le cas d’utilisation indique simplement que l’acteur déclenche cette fonctionnalité. Le rectangle autour représente la frontière du système : ce qui est dedans est à réaliser, ce qui est dehors existe déjà.

Un bon cas d’utilisation se nomme par un verbe à l’infinitif et un complément : « consulter ses notes », « déposer un dossier ». Une ellipse nommée par un seul nom (« Notes ») cache souvent plusieurs fonctionnalités.

graph LR ETU["Acteur Étudiant"] --> CU1["Consulter ses notes"] ETU --> CU2["Déposer un dossier"] ENS["Acteur Enseignant"] --> CU3["Saisir une note"] CU2 -->|include| CU4["Vérifier le format du dossier"]
Point de contrôle : Je place la frontière du système et je nomme chaque cas par un verbe.

Include, extend et flux alternatif

Include indique qu’un cas d’utilisation appelle obligatoirement un autre : « retirer de l’argent » inclut toujours « vérifier le solde ». Le comportement inclus est toujours exécuté, il n’est pas optionnel.

Extend indique un comportement ajouté dans certaines conditions : « retirer de l’argent » peut être étendu par « prévenir la banque si le plafond est atteint ». Le point d’extension précise à quel moment la condition est testée.

Le flux alternatif décrit ce qui se passe quand le chemin nominal échoue : dossier au mauvais format, solde insuffisant, session expirée. Un diagramme de cas d’utilisation sans flux alternatif suppose que tout se passe toujours bien, ce qui ne se produit jamais.

Relation Obligatoire ? Question à se poser
Include Toujours exécuté Ce comportement est-il indispensable à chaque appel ?
Extend Seulement si la condition est vraie Que se passe-t-il quand la condition n’est pas remplie ?
Flux alternatif En cas d’échec Quel message reçoit l’utilisateur, et où en est le système ?

Confondre include et extend est l’erreur classique de l’examen. Test simple : si je supprime la relation, le cas principal reste-t-il complet ? Si oui, c’est un extend. S’il devient incomplet, c’est un include.

Point de contrôle : Je choisis entre include et extend en expliquant mon raisonnement.

Préconditions et postconditions

Une précondition est une condition qui doit être remplie AVANT que le cas d’utilisation puisse démarrer. Une postcondition est ce qui est garanti APRÈS son exécution. Les deux se notent en texte ou par une étiquette dans le diagramme.

Elles servent à délimiter la responsabilité : si la précondition n’est pas remplie, le système n’est pas censé gérer le cas. « L’utilisateur est authentifié » est une précondition ; « le dossier est enregistré et une confirmation est affichée » est une postcondition.

Bien rédigées, elles deviennent directement des cas de test : la précondition est le contexte à installer, la postcondition est le résultat attendu à vérifier.

Cas : Déposer un dossier
Précondition .... l’utilisateur est authentifié et le dossier est ouvert
Postcondition ... le dossier est enregistré, accusé de réception envoyé
Flux nominal .... 1 l’utilisateur choisit le fichier
                     2 le système vérifie le format
                     3 le système enregistre et confirme
Flux alternatif . si le format est refusé (étape 2) : message et retour à l’étape 1
Point de contrôle : Je transforme une postcondition en résultat attendu de test.

Cinq erreurs qui rendent un modèle inutile

Première erreur : modéliser avant d’avoir compris le besoin. Le schéma devient la justification d’une solution choisie trop tôt, au lieu d’explorer le problème.

Deuxième : confondre le modèle et l’implémentation. Un diagramme de classes n’est pas du code : y mettre les getters, setters et classes techniques le rend illisible et obsolète dès la première évolution.

Troisième : utiliser tous les types de diagrammes « pour être complet ». Quatre diagrammes utiles valent mieux que quatorze dessins. On choisit le diagramme en fonction de la question à laquelle il doit répondre.

Quatrième : oublier la cardinalité et les contraintes. « Un étudiant suit des cours » ne dit pas combien, ni si un cours peut exister sans étudiant.

Cinquième : ne jamais mettre le modèle à jour. Un diagramme qui ne correspond plus au code fait plus de dégâts que pas de diagramme du tout : on s’y fie.

Erreur Conséquence Le test qui l’attrape
Modéliser sans besoin Le schéma justifie une solution imposée Montrer le diagramme à l’utilisateur : le reconnaît-il ?
Modèle = code Obsolète au premier changement Compter les classes techniques dedans
Tous les diagrammes Diagrammes jamais relus Supprimer ceux qui ne répondent à aucune question
Cardinalités absentes Ambiguïté sur les données Chercher un cas limite : zéro, un, plusieurs
Modèle non maintenu Fausse confiance Comparer au schéma réel de la base
Point de contrôle : Je relis mon propre diagramme et je dis laquelle de ces cinq erreurs j’ai faite.

Livrables et validation

Le livrable doit montrer une compréhension personnelle, des choix explicités et une vérification par un cas de test ou une procédure reproductible.

  • Un diagramme de cas d’utilisation avec acteurs, include, extend et flux alternatifs.
  • Un diagramme de classes avec attributs, méthodes, cardinalités et relations justifiées.
  • Un tableau de correspondance question du lecteur / type de diagramme choisi.
Critère de réussite : Le modèle est validé quand un lecteur qui n’a pas assisté à la conception peut dire ce que fait le système, quelles données il manipule, et ce qui se passe en cas d’échec.

Exercices, examens et projets

Exercice

Diagrammes UML

Modéliser un domaine avec diagrammes de classes et de séquence.

Obligatoire Consulter
Examen

Examen UML

Évaluer classes, relations et scénarios.

Obligatoire Consulter
Projet

Projet UML

Produire un dossier de modélisation complet.

Livrables :

  • Diagrammes
  • Documentation
Obligatoire Consulter