Module 1Modéliser un projet web
Chapitre 3 sur 12
Classes, attributs, opérations, visibilités, associations, agrégation, composition, héritage, interfaces, et la traduction en PHP 8.
Objectifs
Avec ce chapitre, tu sauras…
Leçon 1
Les cas d'utilisation (chapitre 2) décrivent ce que fait le système, du point de vue des acteurs. La conception objet demande ensuite une description structurelle et statique : quelles classes composent le système, avec quelles données et quels liens entre elles. C'est le rôle du diagramme de classes, considéré comme le plus important de la modélisation objet : c'est le seul obligatoire. Il est statique (il ne montre pas l'ordre des actions dans le temps) et indépendant du langage de programmation.
| Niveau | Diagramme de classes d'analyse (DCA) | Diagramme de classes de conception (DCC) |
|---|---|---|
| contenu | les classes métier issues du cahier des charges | les classes métier plus les classes techniques : vues (interfaces graphiques), contrôleurs, accès aux données |
| exemple | Client, Commande, Livre | CommandeController, CommandeRepository, PanierView |
| détail | attributs principaux, associations | types précis, visibilités, toutes les opérations |
Leçon 2
| Symbole | Visibilité | Accessible depuis… |
|---|---|---|
+ | public | partout |
- | private |
Leçon 3
| Multiplicité | Signification |
|---|---|
0..1 | zéro ou une fois (optionnel) |
1 ou 1..1 | exactement une fois (par défaut) |
* ou 0..* | de zéro à plusieurs |
1..* | au moins une fois |
m..n | entre m et n |
n |
Leçon 4
| Élément | Rôle | Exemple |
|---|---|---|
| nom | décrit la relation, avec un sens de lecture (▶) ; il n'est pas exploité dans le code | Client passe Commande |
| rôle | le nom de l'extrémité : comment un objet est vu de l'autre côté ; il devient souvent le nom de l'attribut | une Personne a le rôle employé, l'Entreprise le rôle employeur |
| multiplicité | combien d'objets de cette classe sont liés à un objet de l'autre classe | une personne travaille pour 1 entreprise ; une entreprise emploie 1..* personnes |
Leçon 5
| Classe concrète | Classe abstraite | Interface | |
|---|---|---|---|
| instances | oui | non : il faut passer par une sous-classe concrète | non |
| contenu | tout est défini | factorise des attributs et des méthodes ; certaines méthodes sont abstraites (non définies) | uniquement des opérations publiques abstraites (pas d'attributs) |
| notation |
Leçon 6
| Élément UML | Traduction PHP |
|---|---|
classe, attribut -, #, + | class, propriété private, protected, public |
attribut [0..1] | type nullable : ?string $sousTitre = null |
| attribut ou méthode statique (souligné) | static |
| classe abstraite, méthode abstraite | abstract class, abstract public function |
| interface, réalisation |
1Le seul diagramme obligatoire d'une modélisation objet est…
2Le symbole # signifie…
3Un attribut souligné est…
4/total désigne un attribut…
5Une commande et ses lignes de commande sont reliées par…
6La relation entre une classe et l'interface qu'elle implémente est…
7Dans Personne "1..*" -- "1" Entreprise, une entreprise emploie…
8En PHP, une association vers plusieurs objets se traduit par…
L'essentiel du chapitre
+ public, - private, # protected, ~ package ; attributs nom : type [multiplicité] = défaut {contrainte} ; statique souligné ; dérivé / ; contraintes {readOnly}, {ordered}, {unique}, {query}.<<use>>) ; association (nom, rôles, multiplicités lues à l'autre bout, navigabilité, réflexive, n-aire, classe-association) ; agrégation (losange vide, parties partageables) ; composition (losange plein, parties détruites avec le tout) ; héritage (triangle vide, « est un »).<<interface>>, contrat), réalisation (pointillé + triangle vide).private/protected, ?type pour [0..1], static, abstract, interface/implements, extends, propriétés objet ou tableau pour les associations.| la classe elle-même uniquement |
# | protected | la classe et ses sous-classes |
~ | package | les classes du même paquetage |
Vidéo · À regarder
FRUML Diagramme de Classe - Cours Complet et exercice sur Astah UML
Prof. Fatimazahra BARRAMOU · YouTube
| exactement n |
| Contrainte | Sens |
|---|---|
{readOnly} | la valeur ne peut plus changer après l'initialisation |
{ordered} | une collection dont les valeurs sont ordonnées |
{unique} | une collection sans doublon (c'est le cas par défaut) |
{nonunique} | une collection qui accepte les doublons |
{query} | une opération qui ne modifie pas l'état de l'objet |
{abstract} | une opération ou une classe abstraite |
Vidéo · À regarder
FRUML Diagramme de Classe - Cours Complet et exercice sur Astah UML
Prof. Fatimazahra BARRAMOU · YouTube
| navigabilité | dans quel sens on peut aller d'un objet à l'autre | une Commande connaît ses Livres ; un Livre ne connaît pas ses commandes |
| Agrégation | Composition | |
|---|---|---|
| sens | « possède » : un tout et ses parties, mais les parties peuvent exister seules et être partagées | « est composé de » : les parties n'appartiennent qu'à un seul tout et disparaissent avec lui |
| symbole | losange vide côté du tout | losange plein côté du tout |
| multiplicité côté tout | quelconque | 1 (ou 0..1) |
| exemple | une Playlist et ses Chansons (une chanson existe sans la playlist) ; une Équipe et ses Joueurs | une Commande et ses Lignes de commande ; un Livre et ses Chapitres |
Vidéo · À regarder
FRUML Diagramme de Classe - Cours Complet et exercice sur Astah UML
Prof. Fatimazahra BARRAMOU · YouTube
Vidéo · À regarder
FRUML Diagramme de Classe - Cours Complet et exercice sur Astah UML
Prof. Fatimazahra BARRAMOU · YouTube
| normale |
nom en italique ou {abstract} ; méthodes abstraites en italique |
<<interface>> |
| relation avec les classes | — | héritage (triangle vide, trait plein) | réalisation (triangle vide, trait pointillé) |
interface, class Commande implements Payable| héritage | class Client extends Utilisateur |
| association navigable vers 1 objet | une propriété typée : private Livre $livre |
association vers plusieurs objets (*) | une propriété tableau : private array $commandes = [] |
| composition | le tout crée ses parties lui-même (new LigneCommande(...) dans Commande) et personne d'autre ne les référence |
| agrégation | le tout reçoit des objets créés ailleurs (en paramètre) |
attribut dérivé /total | une méthode de calcul : getTotal() |
| dépendance | un objet reçu en paramètre ou créé localement dans une méthode |
Vidéo · À regarder
FRUML Diagramme de Classe - Cours Complet et exercice sur Astah UML
Prof. Fatimazahra BARRAMOU · YouTube
Un objet est une entité concrète du système, caractérisée par :
Une classe est la description abstraite d'un ensemble d'objets qui ont les mêmes attributs et les mêmes opérations. C'est le moule à partir duquel on construit les objets. Un objet est une instance de sa classe. Une classe concrète a des instances ; une classe abstraite et une interface n'en ont pas (section 6).
La représentation d'une classe
Une classe est un rectangle à trois compartiments : le nom (commence par une majuscule), les attributs, les opérations. Si on ne s'intéresse qu'aux relations entre classes, on peut laisser les deux derniers compartiments vides ou les masquer.
@startuml
class Livre {
- isbn : String
- titre : String
- sousTitre : String [0..1]
- langue : String = "fr"
- dateParution : Date
- prix : float
- {static} nbLivres : int = 0
+ getPrix() : float
+ appliquerRemise(taux : float) : void
+ estDisponible() : boolean
+ {static} compterLivres() : int
}
@endumlL'encapsulation et la visibilité
L'encapsulation consiste à rassembler les données et les méthodes dans l'objet et à interdire l'accès direct aux données depuis l'extérieur : on passe par les services (méthodes) proposés, qui forment l'interface de l'objet. Elle garantit l'intégrité des données (un prix ne peut pas devenir négatif si setPrix() le vérifie).
La syntaxe d'un attribut
visibilité [/] nom : type [multiplicité] [= valeur_par_défaut] [{contraintes}]
exemples :
- titre : String
- sousTitre : String [0..1] attribut optionnel (tous les livres n'ont pas de sous-titre)
- relevés : float [100] {ordered} une station météo stocke 100 relevés, dans l'ordre
- langue : String = "fr" valeur par défaut
- /âge : int {âge = aujourd'hui - dateNaissance} attribut dérivéLa dépendance
La dépendance est la relation la plus faible : une classe utilise brièvement une autre, sans garder de lien durable (un objet reçu en paramètre d'une méthode, ou créé et détruit dans une méthode). Elle se dessine en pointillé fléché, souvent avec <<use>>.
L'association
Une association est une relation durable entre deux classes : leurs objets restent liés un certain temps, mais chacun peut exister sans l'autre. Elle se dessine par un trait plein, que l'on peut compléter par :
Le diagramme de classes de conception se traduit presque mécaniquement en code orienté objet. Voici le diagramme de la librairie, puis sa traduction en PHP 8.
@startuml
abstract class Utilisateur {
- {static} nbUtilisateurs : int = 0
# nom : String
# email : String
+ {abstract} role() : String
+ {static} nbUtilisateurs() : int
}
class Client {
+ role() : String
+ passerCommande() : Commande
}
interface Payable {
+ montantAPayer() : float
}
class Commande {
- date : DateTime
+ ajouter(livre : Livre, quantite : int = 1) : void
+ getTotal() : float
+ montantAPayer() : float
}
class LigneCommande {
- quantite : int
+ sousTotal() : float
}
class Livre {
- isbn : String
- titre : String
- sousTitre : String [0..1]
- prix : float
+ getPrix() : float
}
Client -up-|> Utilisateur
Commande .up.|> Payable
Client "1" -- "0..*" Commande : passe >
Commande *-- "1..*" LigneCommande
LigneCommande "*" --> "1" Livre
@endumlRéalise le diagramme de classes d'analyse de la librairie Kitab, avec au moins : Utilisateur (abstraite), Client, Libraire, Livre, Auteur, Catégorie (avec sous-catégories), Commande, LigneCommande, Magasin, Stock (la quantité d'un livre dans un magasin), Avis (un client note un livre). Indique les multiplicités, une composition, une classe-association et une association réflexive. Traduis ensuite les classes Livre, Auteur et Avis en PHP.
Écris en syntaxe UML la classe Stagiaire : un identifiant entier en lecture seule, un nom, un prénom, une date de naissance, un âge calculé, un téléphone optionnel, entre 1 et 3 adresses e-mail, une moyenne générale ; un compteur de stagiaires partagé par toute la classe ; une opération qui ajoute une note (paramètres : module et valeur), une opération qui renvoie la moyenne sans modifier l'objet, une opération statique qui renvoie le compteur.
Choisis la relation et justifie : (1) un Immeuble et ses Appartements ; (2) un Panier et les Produits qu'il contient ; (3) un Formateur et un Module qu'il enseigne ; (4) une Voiture et un Véhicule ; (5) une Facture et ses Lignes de facture ; (6) un Groupe de stagiaires et ses Stagiaires ; (7) une Classe PHP qui reçoit un objet Logger en paramètre d'une seule méthode.
En pratique, les attributs sont privés (-) et on y accède par des accesseurs publics (+getPrix(), +setPrix()). C'est ce que tu as appris en POO (M103) et en PHP (M107).
Ce que tu vas voir (4 min) : les chapitres « Diagramme de Classes », « La Classe ». La professeure explique ce qu'est un diagramme de classes et comment on représente une classe (nom, attributs, opérations).
La syntaxe d'une opération
visibilité nom(direction param : type [= défaut], …) : typeRetour [{propriétés}]
exemples :
+ appliquerRemise(in taux : float = 0.1) : void
+ chercher(motCle : String) : Livre [*] {query}in (entrée, par défaut), out (sortie : la valeur est rendue à l'appelant), inout (entrée et sortie). Exemple du résumé, la classe Horloge : régler(in heures : int, in minutes : int) : void reçoit des valeurs ; getTime(out heures : int, out minutes : int) : void en renvoie.{abstract}, {query} (l'opération ne modifie pas l'état de l'objet), préconditions, exceptions.Les membres de classe (statiques)
Un attribut de classe appartient à la classe et non à chaque objet : sa valeur est unique et partagée par toutes les instances (nbLivres compte tous les livres créés). Une méthode de classe s'appelle sans créer d'objet et ne manipule que les attributs statiques et ses paramètres. En UML, ils sont soulignés.
Les contraintes
Une contrainte est une condition écrite entre accolades, en langage naturel ou formel (OCL), appliquée à un attribut, une opération ou une association.
Le résumé cite une contrainte {list} « pour préciser que les valeurs ne sont pas ordonnées » et une contrainte {not null}. Elles n'existent pas dans la norme UML : une collection non ordonnée est le cas par défaut (ou {unordered}), et un attribut obligatoire s'exprime par sa multiplicité [1] (qui est déjà la valeur par défaut). Tu peux en revanche écrire n'importe quelle contrainte métier en langage naturel : {prix > 0}.
Les attributs dérivés
Un attribut dérivé se calcule à partir d'autres informations du modèle (le total d'une commande, l'âge d'une personne). On le garde dans le diagramme s'il est important pour le métier. Il est précédé d'un / et accompagné de sa règle de calcul : /total : float {total = somme des sous-totaux des lignes}. Dans le code, il devient en général une méthode (getTotal()) plutôt qu'une donnée stockée.
Constructeurs et modèles
Les constructeurs et destructeurs sont marqués par les stéréotypes <<create>> et <<destroy>> (un stéréotype est un mot-clé entre guillemets doubles, prédéfini comme <<include>> ou inventé). Une classe paramétrée (template), dessinée avec un petit rectangle pointillé en haut à droite, prend un type en paramètre : Liste<T> peut devenir Liste<Livre>. Elle sert surtout aux collections.
Ce que tu vas voir (10 min) : les chapitres « Les Attributs », « Les Opérations », « La Visibilité Attribut/Opération », « Les Attributs Dérivés », « Attribut ou Opération de classe ». Elle détaille les attributs, les opérations, la visibilité (+, -, #), les attributs dérivés et les membres de classe (statiques).
@startuml
class Personne
class Entreprise
Personne "employé 1..*" -- "employeur 1" Entreprise : travaille pour >
@endumlLa multiplicité se lit à l'autre bout de l'association. Personne "1..*" —— "1" Entreprise se lit : une personne travaille pour 1 entreprise (on lit le 1 côté Entreprise) ; une entreprise emploie 1..* personnes (on lit le 1..* côté Personne). C'est exactement le contraire des cardinalités de Merise (M106), qui s'écrivent du côté de l'entité concernée.
La navigabilité est bidirectionnelle par défaut (chaque classe a un attribut vers l'autre), mais elle est plus complexe à programmer : on préfère souvent la navigabilité unidirectionnelle, indiquée par une flèche du côté de la classe que l'on peut atteindre (et éventuellement une croix du côté non navigable).
@startuml
class Commande
class Livre
Commande "*" --> "1..*" Livre : contient
@endumlLes associations réflexives et n-aires
Une association réflexive relie une classe à elle-même : un Employé encadre d'autres employés ; une Catégorie de livres contient des sous-catégories.
Une association n-aire relie trois classes ou plus ; elle se dessine avec un losange relié à chaque classe. Exemple du résumé : un Cours associe un Enseignant, une Salle et un Groupe. Elle est difficile à interpréter : on la remplace souvent par des associations binaires et une classe intermédiaire.
@startuml
class Catégorie
Catégorie "0..1 parent" -- "* sousCatégories" Catégorie
class Enseignant
class Salle
class Groupe
<> cours
Enseignant -- cours
Salle -- cours
Groupe -- cours
@endumlLa classe-association
Quand une association porte ses propres informations, qui n'appartiennent à aucune des deux classes, on les place dans une classe-association, reliée à l'association par un pointillé. Exemple du résumé : quand une Personne utilise un Téléphone, il faut mesurer la durée de l'appel et sa période tarifaire pour le facturer : ces attributs vont dans la classe Appel.
@startuml
class Personne
class Téléphone
class Appel {
durée : int
périodeTarifaire : String
}
Personne "*" -- "*" Téléphone
(Personne, Téléphone) .. Appel
@endumlTableau: L'agrégation et la composition
@startuml
class Playlist
class Chanson
class Commande
class LigneCommande
Playlist o-- "*" Chanson
Commande *-- "1..*" LigneCommande
@endumlLa définition de la composition du résumé inverse les rôles : elle dit que l'objet A (le conteneur) « n'appartient qu'à l'objet B » et que « si l'objet A disparaît, l'objet B disparaît aussi ». Il faut lire : le composant B n'appartient qu'au conteneur A, et si A (le tout) disparaît, B (la partie) disparaît aussi. L'exemple du résumé est juste : le châssis n'appartient qu'à une voiture. Celui des roues (agrégation) est discutable : on retient plutôt qu'une roue peut être démontée et remontée sur une autre voiture.
L'héritage
L'héritage (généralisation/spécialisation) relie une classe fille (sous-classe) à une classe mère (super-classe) : la fille hérite de tous les attributs et opérations de la mère et peut en ajouter ou en redéfinir. Il se dessine par une flèche à triangle vide vers la classe mère. On vérifie un héritage par la phrase « est un » : un Client est un Utilisateur.
Ce que tu vas voir (11 min) : les chapitres « Association », « Association Réflexive », « Classe d'Association », « Association n-aire », « Nom de Rôle », « Navigabilité », « Cardinalité ». Première partie des relations : l'association, l'association réflexive, la classe d'association, le nom de rôle, la navigabilité et la cardinalité.
Ce que tu vas voir (11 min) : les chapitres « Dépendance », « Agrégation et composition », « Généralisation ». Deuxième partie : la dépendance, l'agrégation, la composition et la généralisation (héritage).
Une interface regroupe un ensemble d'opérations qui forment un service cohérent : c'est un contrat. Une classe qui réalise (implémente) l'interface est obligée de définir toutes ses opérations. L'objectif est de réduire le couplage : une classe qui utilise l'interface Payable peut travailler avec n'importe quelle classe qui la réalise (une Commande, un Abonnement), sans les connaître.
@startuml
abstract class Utilisateur {
# nom : String
# email : String
+ {abstract} role() : String
}
class Client {
+ role() : String
+ passerCommande() : Commande
}
class Libraire {
+ role() : String
+ traiterCommande(c : Commande) : void
}
interface Payable {
+ montantAPayer() : float
}
class Commande {
- date : Date
- /total : float
+ montantAPayer() : float
}
Client -up-|> Utilisateur
Libraire -up-|> Utilisateur
Commande .up.|> Payable
Client "1" -- "0..*" Commande : passe >
@enduml<?php
declare(strict_types=1);
interface Payable
{
public function montantAPayer(): float;
}
abstract class Utilisateur
{
private static int $nbUtilisateurs = 0; // attribut de classe (souligné en UML)
public function __construct(
protected string $nom,
protected string $email,
) {
self::$nbUtilisateurs++;
}
abstract public function role(): string; // méthode abstraite (en italique en UML)
public static function nbUtilisateurs(): int
{
return self::$nbUtilisateurs;
}
public function getNom(): string
{
return $this->nom;
}
}
class Client extends Utilisateur
{
private array $commandes = []; // association 1 —— 0..* Commande
public function role(): string
{
return 'client';
}
public function passerCommande(): Commande
{
$c = new Commande($this);
$this->commandes[] = $c;
return $c;
}
public function nbCommandes(): int
{
return count($this->commandes);
}
}
class Livre
{
public function __construct(
private string $isbn,
private string $titre,
private float $prix,
private ?string $sousTitre = null, // multiplicité [0..1]
) {}
public function getPrix(): float
{
return $this->prix;
}
}
class LigneCommande
{
public function __construct(
private Livre $livre, // association navigable vers Livre
private int $quantite,
) {}
public function sousTotal(): float
{
return $this->livre->getPrix() * $this->quantite;
}
}
class Commande implements Payable
{
private array $lignes = []; // composition : la commande possède ses lignes
private DateTimeImmutable $date;
public function __construct(private Client $client)
{
$this->date = new DateTimeImmutable();
}
public function ajouter(Livre $livre, int $quantite = 1): void
{
$this->lignes[] = new LigneCommande($livre, $quantite); // la commande crée ses lignes
}
public function getTotal(): float // attribut dérivé /total
{
return array_sum(array_map(fn (LigneCommande $l) => $l->sousTotal(), $this->lignes));
}
public function montantAPayer(): float
{
return $this->getTotal();
}
}
$sara = new Client('Sara Alaoui', 'sara@exemple.ma');
$c = $sara->passerCommande();
$c->ajouter(new Livre('9789954', "L'Alchimiste", 95.0), 2);
$c->ajouter(new Livre('9782070', 'Le Petit Prince', 60.0));
echo $sara->getNom(), ' (', $sara->role(), ') : ', $c->montantAPayer(), " DH\n";
// Sara Alaoui (client) : 250 DH
echo Utilisateur::nbUtilisateurs(), "\n"; // 1
// new Utilisateur('x', 'y'); → Error : Cannot instantiate abstract class UtilisateurLe même diagramme sert aussi à créer les tables (comme le MCD de Merise au M106) : chaque classe persistante devient une table ; une association 1 —— * devient une clé étrangère du côté * (commande.client_id) ; une association * —— * ou une classe-association devient une table d'association ; la composition se traduit souvent par ON DELETE CASCADE. Les frameworks comme Laravel et Symfony (chapitre 11) font ce lien automatiquement avec leurs ORM.
Ce que tu vas voir (jusqu'à la fin) : les chapitres « Démarche d'élaboration d'un diagramme de classe », « Démonstration sur Astah UML ». Elle donne la démarche pour construire un diagramme de classes à partir d'un énoncé, puis le dessine sur Astah UML.
Pour le diagramme de conception de la commande (section 6), réponds : (1) combien de commandes un client peut-il avoir ? (2) une ligne de commande peut-elle exister sans commande ? (3) peut-on, à partir d'un livre, retrouver les commandes qui le contiennent ? (4) pourquoi Utilisateur est-elle abstraite ? (5) que doit faire une classe Abonnement pour pouvoir être payée comme une commande ?