Comprendre et Créer des Diagrammes de Classes UML avec Mermaid.js
Ce tutoriel explore les diagrammes de classes en UML avec des exemples pratiques et l'utilisation de Mermaid.js pour visualiser les diagrammes.
1. Introduction aux Diagrammes de Classes UML
Les diagrammes de classes sont un élément clé en UML pour modéliser la structure d'un système orienté objet. Ils permettent de représenter les classes, leurs attributs, leurs méthodes, ainsi que les relations entre elles.
2. Concepts de Base des Diagrammes de Classes
Classes
Une classe est une structure qui définit les attributs et les comportements d'un objet. En UML, une classe est représentée par un rectangle divisé en trois sections : nom de la classe, attributs et méthodes.
Attributs et Méthodes
Les attributs représentent les données que possède chaque objet de la classe, tandis que les méthodes définissent les actions que ces objets peuvent réaliser.
Relations entre Classes
Les classes peuvent être reliées entre elles par différents types de relations :
- Association : Relation simple entre deux classes.
- Agrégation : Relation “tout/partie” où une classe contient d'autres classes sans en être propriétaire.
- Composition : Type d'agrégation forte où une classe contient et possède d'autres classes.
- Héritage : Relation “est-un” où une classe dérive d'une autre classe.
3. Exemples de Diagrammes de Classes
Exemple 1 : Système de Gestion de Bibliothèque
Ce diagramme montre les relations entre les classes dans un système de gestion de bibliothèque.
classDiagram
class Livre {
-String titre
-String auteur
-int ISBN
+emprunter()
+retourner()
}
class Membre {
-String nom
-int idMembre
+inscrire()
+emprunterLivre()
}
class Bibliotheque {
-List~Livre~ livres
-List~Membre~ membres
+ajouterLivre()
+ajouterMembre()
}
Bibliotheque "many" *-- "many" Livre : contient
Membre "1" o-- "many" Livre : emprunte
Relation:Association
Exemple 1 : Association dans un Système de Gestion de Bibliothèque
Dans ce système de bibliothèque, chaque Auteur est associé à plusieurs Livre, et chaque livre peut être écrit par un ou plusieurs auteurs.
classDiagram
class Auteur {
- String nom
- String nationalite
+ ecrireLivre()
}
class Livre {
- String titre
- int anneePublication
+ publier()
}
Auteur "many" -- "many" Livre : écrit
Exemple 2 : Association dans un Système de Gestion de Projets
Dans ce système de gestion de projets, chaque Employé peut être associé à un ou plusieurs Projet, et chaque projet peut avoir plusieurs employés travaillant dessus.
classDiagram
class Employe {
- String nom
- String poste
+ rejoindreProjet()
}
class Projet {
- String nomProjet
- Date dateDebut
+ demarrerProjet()
}
Employe "many" -- "many" Projet : travaille sur
Exemple 3 : Association dans un Système de Gestion de Cours Universitaires
Dans ce système universitaire, chaque Professeur peut enseigner plusieurs Cours, et chaque cours peut être enseigné par un ou plusieurs professeurs.
classDiagram
class Professeur {
- String nom
- String specialisation
+ enseigner()
}
class Cours {
- String nomCours
- int credits
+ commencerCours()
}
Professeur "many" -- "many" Cours : enseigne
Relation:Agrégation
Exemple 1 : Agrégation dans un Système de Gestion d'Enseignement
Dans ce système, un Cours est composé de plusieurs Etudiants, mais un étudiant peut également être inscrit à plusieurs cours. L'agrégation montre que le cours existe indépendamment des étudiants.
classDiagram
class Cours {
- String nomCours
- int credits
+ ajouterEtudiant()
}
class Etudiant {
- String nom
- int numeroEtudiant
+ sInscrire()
}
Etudiant "many" o-- "many" Cours : s'inscrit à
Exemple 3 : Agrégation dans un Système de Gestion de Projet
Dans ce système, un Projet est composé de plusieurs Taches, mais chaque tâche peut exister indépendamment de son projet. Cela illustre également une relation d'agrégation.
classDiagram
class Projet {
- String nomProjet
- Date dateDebut
+ demarrer()
}
class Tache {
- String description
- int duree
+ executer()
}
Projet "1" o-- "many" Tache : contient
Relation:Composition
Exemple 1 : Composition dans un Système de Gestion de Véhicules
Dans ce système, un Véhicule est composé de plusieurs Roues. Les roues n'ont pas de sens sans le véhicule, illustrant ainsi une relation de composition.
classDiagram
class Vehicule {
- String type
- String marque
+ demarrer()
}
class Roue {
- int taille
- String typeRoue
+ tourner()
}
Vehicule "1" *-- "4" Roue : contient
Exemple 2 : Composition dans un Système de Gestion de Salle de Concert
Dans ce système, un Concert est composé de plusieurs Musiciens. Un musicien fait partie d'un concert spécifique et ne peut pas exister en dehors de celui-ci, illustrant une relation de composition.
classDiagram
class Concert {
- String nom
- Date dateConcert
+ commencer()
}
class Musicien {
- String nom
- String instrument
+ jouer()
}
Concert "1" *-- "many" Musicien : comprend
Exemple 3 : Composition dans un Système de Gestion de Maison
Dans ce système, une Maison est composée de plusieurs Chambres. Chaque chambre ne peut pas exister sans la maison, ce qui illustre une relation de composition.
classDiagram
class Maison {
- String adresse
- int superficie
+ ouvrirPortes()
}
class Chambre {
- String typeChambre
- int superficie
+ decorer()
}
Maison "1" *-- "many" Chambre : contient
Relation:Héritage
Exemple 1 : Héritage dans un Système de Gestion de Personnel
Dans ce système, une classe Employe est la classe parent d'où héritent les classes Manager et Technicien. Les managers et techniciens partagent des caractéristiques communes avec la classe employé.
classDiagram
class Employe {
- String nom
- int id
+ travailler()
}
class Manager {
- String departement
+ organiser()
}
class Technicien {
- String specialite
+ reparer()
}
Employe <|-- Manager : hérite
Employe <|-- Technicien : hérite
Exemple 2 : Héritage dans un Système de Gestion de Véhicules
Dans ce système, la classe Vehicule est la classe parent dont héritent les classes Voiture et Camion. Les voitures et camions partagent des propriétés communes avec la classe véhicule.
classDiagram
class Vehicule {
- String marque
- String modele
+ demarrer()
}
class Voiture {
- int nombrePortes
+ ouvrirCoffre()
}
class Camion {
- double capaciteCharge
+ charger()
}
Vehicule <|-- Voiture : hérite
Vehicule <|-- Camion : hérite
Exemple 3 : Héritage dans un Système de Gestion d'Animaux
Dans ce système, la classe Animal est la classe parent dont héritent les classes Mammifere et Oiseau. Les mammifères et oiseaux partagent des caractéristiques communes avec la classe animal.
classDiagram
class Animal {
- String nom
- int age
+ manger()
}
class Mammifere {
- String typeFourrure
+ allaiter()
}
class Oiseau {
- String typePlume
+ voler()
}
Animal <|-- Mammifere : hérite
Animal <|-- Oiseau : hérite
Exemple 2 : Système de Gestion des Étudiants
Ce diagramme montre les relations entre les classes dans un système de gestion des étudiants.
classDiagram
class Etudiant {
-String nom
-int idEtudiant
+sInscrire()
}
class Cours {
-String nomCours
-String codeCours
+ajouterEtudiant()
}
class Universite {
-List~Etudiant~ etudiants
-List~Cours~ cours
+inscrireEtudiant()
+ajouterCours()
}
Universite "1" *-- "many" Etudiant : gère
Universite "1" *-- "many" Cours : offre
Cours "1" *-- "many" Etudiant : contient
Voici un exemple simple d'un diagramme de classes avec Mermaid.js :
classDiagram
class Animal {
+String nom
+int age
+manger()
}
class Chien {
+aboyer()
}
class Chat {
+miauler()
}
Animal <|-- Chien
Animal <|-- Chat
Exemple Avancé 1 : Système de Réservation de Vols
Ce diagramme représente un système de réservation de vols avec des classes telles que Client, Réservation, Vol, et Avion. Ce modèle inclut des relations de composition et d'association pour illustrer les connexions entre les entités.
classDiagram
class Client {
- String nom
- String adresseEmail
+ faireReservation()
}
class Reservation {
- int numeroReservation
- Date dateReservation
+ annuler()
}
class Vol {
- String numeroVol
- Date dateDepart
- Date dateArrivee
+ verifierDisponibilite()
}
class Avion {
- String modele
- int capacite
+ verifierMaintenance()
}
Client "1" o-- "many" Reservation : crée
Reservation "1" --> "1" Vol : pour
Vol "1" o-- "1" Avion : utilise
Exemple Avancé 2 : Système de Commerce Électronique
Ce diagramme montre la structure d’un système de commerce électronique avec les classes Utilisateur, Produit, Commande, et Paiement. Il inclut des relations d'héritage, d'agrégation, et de composition.
classDiagram
class Utilisateur {
- String nom
- String email
+ sInscrire()
+ seConnecter()
}
class Client
class Admin
Utilisateur <|-- Client
Utilisateur <|-- Admin
class Produit {
- String nomProduit
- float prix
+ ajouterAuPanier()
}
class Commande {
- int numeroCommande
- Date dateCommande
+ annulerCommande()
}
class Panier {
- List~Produit~ produits
+ calculerTotal()
}
class Paiement {
- float montant
+ traiterPaiement()
}
Client "1" o-- "1" Panier : possède
Panier "1" o-- "many" Produit : contient
Commande "1" *-- "1" Paiement : contient
Client "1" --> "many" Commande : passe
Commande "many" --> "many" Produit : contient
Exemple Avancé 3 : Système de Gestion d'Hôpital
Ce diagramme illustre un système de gestion d'hôpital avec des classes pour Médecin, Patient, Dossier Médical, et Rendez-vous, montrant des relations complexes entre elles.
classDiagram
class Medecin {
- String nom
- String specialite
+ planifierRendezVous()
}
class Patient {
- String nom
- int age
+ prendreRendezVous()
}
class DossierMedical {
- int numeroDossier
- List~String~ historiqueMaladies
+ ajouterHistorique()
}
class RendezVous {
- Date dateRendezVous
- String statut
+ annuler()
}
Medecin "1" o-- "many" RendezVous : programme
Patient "1" --> "many" RendezVous : prend
Patient "1" --> "1" DossierMedical : possède
DossierMedical "1" --> "many" RendezVous : contient