Diagrammes de Classes UML

Guide complet avec exemples détaillés en français

Table des Matières

Introduction aux Diagrammes de Classes

Qu'est-ce qu'un Diagramme de Classes UML ?

Un diagramme de classes UML (Unified Modeling Language) est un type de diagramme de structure qui montre la structure d'un système en modélisant les classes du système, leurs attributs, leurs opérations et les relations entre les objets. C'est l'un des diagrammes les plus utilisés en conception orientée objet.

Exemple 1 : Système de Gestion d'École

classDiagram class Ecole { +String nom +String adresse +int nombreEtudiants() +void ajouterEtudiant() } class Etudiant { +String nom +String matricule +Date dateNaissance +void inscrire() +void desinscrire() } class Professeur { +String nom +String specialite +void enseigner() +void corriger() }

Ce diagramme montre les classes de base pour un système de gestion d'école avec leurs attributs et méthodes principales.

Exemple 2 : Système de Bibliothèque

classDiagram class Bibliotheque { +String nom +String adresse +List~Livre~ livres +void ajouterLivre() +Livre rechercherLivre() } class Livre { +String titre +String auteur +String isbn +boolean estDisponible +void emprunter() +void retourner() } class Utilisateur { +String nom +String email +List~Livre~ livresEmpruntes +void emprunterLivre() +void retournerLivre() }

Ce diagramme représente un système de bibliothèque avec les classes principales et leurs responsabilités.

Classes et Attributs

Structure d'une Classe

Une classe UML est représentée par un rectangle divisé en trois compartiments : Nom de la classe (haut), Attributs (milieu), et Opérations/Méthodes (bas).

Exemple 1 : Classe Voiture Détaillée

classDiagram class Voiture { -String marque -String modele -int annee -double prix -boolean estDemarree +void demarrer() +void arreter() +void accelerer(int vitesse) +double getConsommation() -void verifierEssence() }

Cette classe Voiture montre différents types d'attributs (String, int, double, boolean) et méthodes publiques et privées.

Exemple 2 : Classe Compte Bancaire

classDiagram class CompteBancaire { -String numeroCompte -String titulaire -double solde -Date dateOuverture +void deposer(double montant) +boolean retirer(double montant) +double getSolde() +List~Transaction~ getHistorique() -void genererReleve() }

Cette classe montre des attributs avec des types complexes comme Date et List, ainsi que des méthodes avec paramètres.

Héritage (Généralisation)

Relation d'Héritage

L'héritage est représenté par une flèche pleine avec un triangle à l'extrémité pointant vers la classe parente. La classe enfant hérite des attributs et méthodes de la classe parente.

Exemple 1 : Hiérarchie des Animaux

classDiagram Animal <|-- Chien Animal <|-- Chat Animal <|-- Oiseau class Animal { <<abstract>> +String nom +int age +void manger() +abstract void faireDuBruit() } class Chien { +void faireDuBruit() +void aboyer() } class Chat { +void faireDuBruit() +void ronronner() } class Oiseau { +void faireDuBruit() +void voler() }

Chien, Chat et Oiseau héritent d'Animal. Chaque classe enfant implémente la méthode abstraite faireDuBruit() de manière spécifique.

Exemple 2 : Hiérarchie des Employés

classDiagram Employe <|-- Manager Employe <|-- Developpeur Employe <|-- Vendeur class Employe { <<abstract>> +String nom +String matricule +double salaire +void travailler() +abstract double calculerSalaire() } class Manager { +List~Employe~ equipe +void gererEquipe() +double calculerSalaire() } class Developpeur { +List~String~ competences +void coder() +double calculerSalaire() } class Vendeur { +double chiffreAffaires +void vendre() +double calculerSalaire() }

Les classes spécialisées héritent des attributs et méthodes communes, tout en ayant leurs propres spécificités et implémentations de calculerSalaire().

Association

Relation d'Association

L'association représente une relation structurelle entre deux classes. Elle est représentée par une ligne simple entre les classes, avec éventuellement des rôles et multiplicités.

Exemple 1 : Association simple entre Client et Commande

classDiagram Client "1" -- "0..*" Commande : passe class Client { +String nom +String email +String telephone +void creerCompte() } class Commande { +int numero +Date date +double montantTotal +void ajouterArticle() +void valider() }

Un Client peut passer zéro ou plusieurs Commandes. Chaque Commande est passée par exactement un Client.

Exemple 2 : Association bidirectionnelle entre Médecin et Patient

classDiagram Medecin "0..*" -- "0..*" Patient : traite / consulte class Medecin { +String nom +String specialite +String numeroLicence +void diagnostiquer() +void prescrire() } class Patient { +String nom +Date dateNaissance +String numeroSecu +void prendreRendezVous() +void consulter() }

Un Médecin peut traiter plusieurs Patients et un Patient peut consulter plusieurs Médecins. L'association est bidirectionnelle.

Agrégation

Relation d'Agrégation

L'agrégation est une forme spéciale d'association qui représente une relation "tout-partie" où les parties peuvent exister indépendamment du tout. Représentée par une ligne avec un losange vide du côté du "tout".

Exemple 1 : Université et Départements

classDiagram Universite o-- Departement class Universite { +String nom +String adresse +int nombreEtudiants +void ajouterDepartement() } class Departement { +String nom +String chef +List~Professeur~ professeurs +void organiserCours() }

Une Université est composée de plusieurs Départements. Les Départements peuvent exister indépendamment de l'Université.

Exemple 2 : Panier et Articles

classDiagram Panier o-- Article class Panier { +List~Article~ articles +double montantTotal +void ajouterArticle() +void retirerArticle() +void vider() } class Article { +String nom +double prix +int quantite +double getSousTotal() }

Un Panier contient plusieurs Articles. Les Articles peuvent exister sans être dans un Panier (stock, catalogue).

Composition

Relation de Composition

La composition est une forme forte d'agrégation où les parties ne peuvent pas exister indépendamment du tout. Représentée par une ligne avec un losange rempli du côté du "tout".

Exemple 1 : Maison et Pièces

classDiagram Maison *-- Piece class Maison { +String adresse +int nombrePieces +double surfaceTotale +void construire() +void demolir() } class Piece { +String nom +double surface +String type +void reparer() }

Une Maison est composée de Pièces. Si la Maison est détruite, les Pièces cessent d'exister (dans le contexte du modèle).

Exemple 2 : Commande et Lignes de Commande

classDiagram Commande *-- LigneCommande class Commande { +int numero +Date date +String statut +double montantTotal +void valider() +void annuler() } class LigneCommande { +Article article +int quantite +double prixUnitaire +double getSousTotal() }

Une Commande est composée de Lignes de Commande. Les Lignes de Commande ne peuvent pas exister sans une Commande.

Dépendance

Relation de Dépendance

La dépendance représente une relation où un changement dans une classe peut affecter l'autre. Représentée par une flèche en pointillés avec une flèche pleine.

Exemple 1 : Service de Paiement et Commande

classDiagram Commande ..> ServicePaiement : utilise class Commande { +int numero +double montant +void valider() +boolean payer(ServicePaiement service) } class ServicePaiement { +boolean traiterPaiement(double montant) +String genererRecu() }

La classe Commande dépend de ServicePaiement pour traiter les paiements. La dépendance est temporaire et contextuelle.

Exemple 2 : Logger et différentes Classes

classDiagram Utilisateur ..> Logger : utilise Systeme ..> Logger : utilise Application ..> Logger : utilise class Utilisateur { +String nom +void seConnecter() } class Systeme { +void demarrer() +void arreter() } class Application { +void executer() +void terminer() } class Logger { +static void log(String message) +static void error(String message) }

Plusieurs classes dépendent de Logger pour enregistrer des informations. Logger est utilisé de manière statique.

Réalisation

Relation de Réalisation

La réalisation montre qu'une classe implémente une interface. Représentée par une flèche en pointillés avec un triangle vide pointant vers l'interface.

Exemple 1 : Interfaces de Paiement

classDiagram IPaiement <|.. CarteCredit IPaiement <|.. PayPal IPaiement <|.. VirementBancaire class IPaiement { <<interface>> +boolean traiter(double montant) +String getNumeroTransaction() } class CarteCredit { +String numeroCarte +String titulaire +boolean traiter(double montant) +String getNumeroTransaction() } class PayPal { +String email +boolean traiter(double montant) +String getNumeroTransaction() } class VirementBancaire { +String rib +boolean traiter(double montant) +String getNumeroTransaction() }

Différentes classes implémentent l'interface IPaiement, chacune avec sa propre implémentation de la méthode traiter().

Exemple 2 : Interfaces de Notification

classDiagram INotification <|.. EmailNotification INotification <|.. SMSNotification INotification <|.. PushNotification class INotification { <<interface>> +void envoyer(String destinataire, String message) +String getType() } class EmailNotification { +String serveurSMTP +void envoyer(String destinataire, String message) +String getType() } class SMSNotification { +String operateur +void envoyer(String destinataire, String message) +String getType() } class PushNotification { +String plateforme +void envoyer(String destinataire, String message) +String getType() }

Chaque classe implémente l'interface INotification avec des méthodes spécifiques à son type de notification.

Multiplicité

Notations de Multiplicité

La multiplicité définit combien d'instances d'une classe peuvent être associées à une instance d'une autre classe. Notations courantes : 1 (exactement un), 0..1 (zéro ou un), 0..* (zéro ou plusieurs), 1..* (un ou plusieurs).

Exemple 1 : Système de Gestion d'École Complexe

classDiagram Ecole "1" -- "0..*" Etudiant : accueille Ecole "1" -- "1..50" Professeur : emploie Professeur "1" -- "0..5" Cours : enseigne Etudiant "1..*" -- "1..*" Cours : suit Cours "1" -- "1" Salle : se déroule dans class Ecole { +String nom +String adresse } class Etudiant { +String nom +String matricule } class Professeur { +String nom +String specialite } class Cours { +String code +String intitule } class Salle { +String numero +int capacite }

Ce diagramme montre différentes multiplicités : une école peut avoir 0 ou plusieurs étudiants, 1 à 50 professeurs, etc.

Exemple 2 : Système de Commande avec Multiplicités Complexes

classDiagram Client "1" -- "0..*" Commande : passe Commande "1" -- "1..*" LigneCommande : contient LigneCommande "0..*" -- "1..1" Produit : contient Client "1" -- "0..3" Adresse : possède Produit "0..*" -- "1" Categorie : appartient à class Client { +String nom +String email } class Commande { +int numero +Date date } class LigneCommande { +int quantite +double prixUnitaire } class Produit { +String nom +double prix } class Adresse { +String rue +String ville } class Categorie { +String nom }

Ce diagramme illustre des multiplicités variées : un client peut avoir jusqu'à 3 adresses, un produit peut appartenir à plusieurs catégories.

Visibilité

Symboles de Visibilité

La visibilité définit l'accessibilité des attributs et méthodes : + (public), - (private), # (protected), ~ (package).

Exemple 1 : Classe Compte Bancaire avec Visibilités

classDiagram class CompteBancaire { -String numeroCompte -double solde #String titulaire ~Date dateCreation +double getSolde() +void deposer(double montant) +boolean retirer(double montant) #void genererNumero() ~List~Transaction~ getTransactions() -void verifierSolde() }

Les attributs et méthodes sont classés par visibilité : privé (-), protégé (#), package (~), et public (+).

Exemple 2 : Hiérarchie avec Visibilités Héritées

classDiagram Vehicule <|-- Voiture class Vehicule { -String marque #int anneeFabrication +void demarrer() #void arreter() -void verifierMoteur() } class Voiture { -int nombrePortes +void ouvrirCoffre() #void changerVitesse() }

La classe Voiture hérite des attributs et méthodes protégés (#) de Vehicule, mais pas des privés (-).