Diagramme de Classes

Définitions
! Diagramme de Classe : Représentation abstraite des objets
du système qui vont interagir ensemble pour la réalisation des
cas d’utilisation.
! Vue statique : facteur temps pas pris en compte dans le
comportement du système.
! Modélisation des concepts du domaine d’application ainsi que
des concepts internes.
! => modélisation des classes du système et leurs relations
indépendamment d’un langage de programmation particulier.
! Les principaux éléments les classes et leurs relations :
association, généralisation et plusieurs types de dépendances,
telles que la réalisation et l’utilisation.

S. Mouline UML - Class Diagram 2

 Diagramme de classe : exemple
Commande Client Classe
Multiplicité : obligatoire
dateDeRéception Association nom
1 Attributs
estPrépayée * adresse
nombre : Chaîne
prix : Monnaie solvabilité() : Chaîne Opérations
expédier() Généralisation
fermer() {siCommande.client.solvabilté est "douteuse",
alors Commande.estPrépayée doit être vrai}
1 Client Professionnel Client Particulier
Contrainte nomDuContact numéroCarteDeCrédit
solvabilité
Nom du rôle Multiplicité : multi-valuée
créditAutorisé
ligne * Rappeler()
factureMensuelle(Entier)
Ligne de Commande
quantité : Entier * Multiplicité : optionnelle
* 1 Produit
prix : Monnaie
disponible : Booléen 0..1 commercial
Employé

S. Mouline UML - Class Diagram 3

 La classe

! Une classe est un concept abstrait qui représente

divers éléments du système :
! éléments concrets comme des étudiants,
! éléments abstraits comme des inscriptions,
! partie d’une application comme des boîtes de dialogue,
! structures informatiques comme des tables de hachage,
! éléments comportementaux comme des traitements.
! Une classe est associée à d’autres classes

S. Mouline UML - Class Diagram 4

 Instance d’une classe
! Une instance est une concrétisation d’un concept abstrait.
Par exemple :
! le Maroc est une instance du concept abstrait Pays ;
! la FSR est une instance du concept abstrait Etablissement Supérieur
! L’étudiant Ali est une instance du concept abstrait Etudiant
! L’inscription de Ali à la FSR est une instance du concept abstrait Inscription

! Un objet est une instance d’une classe.

! C’est une entité discrète dotée d’une identité, d’un état et d’un
comportement.
! Les objets sont des éléments individuels d’un système en cours d’exécution
! Les objets sont reliés entre eux (par des associations).

! Exemple :
! Si : Etudiant est un concept abstrait, on peut dire que l’étudiant Ali est une
instance de Etudiant.
! Si Etudiant était une classe, Ali en serait une instance : un objet.

S. Mouline UML - Class Diagram 5

 Etat et comportement d’un objet
! État d’un objet :
! Ce sont les attributs et les terminaisons d’associations qui décrivent
l’état d’un objet.
! Les propriétés décrites par les attributs prennent des valeurs lorsque
la classe est instanciée.
! L’instance d’une association est appelée un lien.

! Comportement d’un objet :

! Les opérations décrivent les éléments individuels d’un
comportement que l’on peut invoquer.
! Ce sont des fonctions qui peuvent prendre des valeurs en entrée et
modifier les attributs ou produire des résultats.
! Une opération est la spécification (i.e. déclaration) d’une méthode..

! Les attributs, les terminaisons d’association et les opérations

constituent donc les propriétés d’une classe (et de ses
instances).
S. Mouline UML - Class Diagram 6
 Représentation graphique
« class » « class »
Class_name Class_name
Bonnes pratiques : -attribut1:Integer
• Privé (-) pour les attributs
Encapsulation
• Public (+) pour les opérations -attribut2: String
+operation1() : void
Visibilités : +operation2() : void
public ou + : tout élément qui peut voir l’objet peut également voir
l’élément indiqué.
protected ou # : seul un élément situé dans l’objet ou un de ses
descendants peut voir l’élément indiqué.
private ou - : seul un élément situé dans l’objet peut voir l’élément.
package ou ~ ou rien : seul un élément déclaré dans le même paquetage
peut voir l’élément.

UML 2.0 : spécification de la visibilité par un langage de programmation est

possible.

Interface : services accessibles aux utilisateurs de l’objet (vue externe).

S. Mouline UML - Class Diagram 7
 Attribut d’une classe
! Un attributs définit des caractéristiques qu’une classe ou d’un
objet. Il est définit par :
! Un nom, un type de données, une visibilité et peut être initialisé.
! Le nom de l’attribut doit être unique dans la classe.

! La syntaxe de la déclaration d’un attribut est la suivante :

<visibilité> [/] <nom_attribut>:

<Type> [ ’[’ <multiplicité> ’]’ [ ’{’ <contrainte> ’}’ ] ]
[ = <valeur_par_défaut> ]

! <Type> : nom de classe, nom d’interface ou type de donné

! <multiplicité> : nombre de valeurs que l’attribut peut contenir. (si > 1
possibilité d’ajout d’une contrainte
! <contrainte> : précision sur les valeurs ({ordered}, {list} …).

S. Mouline UML - Class Diagram 8

 Attribut dérivé
! Attributs dérivés d'autres attributs

Personne
dateNaiss
/âge
/âge=dateCourante_dateNaiss

S. Mouline UML - Class Diagram 9

 Opération d’une classe (1)

! Une opération est un traitement que l'on peut faire sur un objet
instance de la classe.

! Elle a un nom et peut avoir des paramètres et un résultat.

! Dans une même classe deux opérations ne peuvent pas avoir le

même nom et les mêmes types de paramètres (unicité de
l'interface).

! On ne déclare que l'interface de l'opération.

! Appel : o.op()

S. Mouline UML - Class Diagram 10

 Opération d’une classe (2)
! Syntaxe :
<visibilité> <nom_méthode> ( [ <paramètre> [, <paramètre> [, <paramètre> ...] ] ] ) :
[<valeur_renvoyé>] [ { <propriétés> } ]

– La syntaxe de définition d’un paramètre (<paramètre>) :

[<direction>] <nom_paramètre>:<Type> [’[’<multiplicité>’]’] [=<valeur_par_défaut>]
– La direction :
in : valeur. (par défaut)
out : sortie
inout : entrée/sortie
– <Type> classe, interface ou type de donné
– <propriétés> " contraintes ou informations (exceptions, les préconditions, les
postconditions ou indication qu’une méthode est abstraite (mot-clef abstract),
…)

S. Mouline UML - Class Diagram 11

 Opération d’une classe (3)
! Cas particulers d'opération :
– Les constructeurs :
• Opérations qui permettent de créer un objet instance
de la classe
• Plusieurs constructeurs peuvent exister pour la
même classe.
• Exemple pour la classe Etudiant :

creer() : Etudiant ;
creer (CIN, CNE, Nom, Prénom) : Etudiant ;

Surcharge du 1er

S. Mouline UML - Class Diagram 12

 Opération d’une classe (4)
! Cas particulers d'opération :
– Les accesseurs :
• Opérations qui permettent d'accéder aux attributs
des objets soit en lecture (get) soit en écriture (set)

• Exemple pour la classe Etudiant :

getNom () : String
getCNE() : String Accès à la valeur d'un attribut

setAdresse(adr : String) : void

Mise à jour de la valeur d'un attribut

S. Mouline UML - Class Diagram 13

 Exemple de classe

Attributs
privés

Constructeurs

Accesseurs

Autre
opération

S. Mouline UML - Class Diagram 14

 Attribut de classe

! Un attribut qui s'applique à une classe et non a une

instance de cette classe
! Dans un DC les attributs de classe sont soulignés

Client
nb_clients
nom
adresse
solvabilité() : Chaîne

S. Mouline UML - Class Diagram 15

 Méthode de classe

! Un méthode qui s'applique à une classe et non a

une instance de cette classe
! Dans un DC les méthodes de classe sont soulignés

Client
nb_clients
nom
adresse
Nb_cli_ville(ville) : Integer

S. Mouline UML - Class Diagram 16

 Exemple de classe

Attribut
de classe

Opération
de classe

S. Mouline UML - Class Diagram 17

 Association entre classes (1)
! Relation entre classes décrivant les liens structurels entre leurs
instances.

1..* Inscrit dans 1

Personne + étudiant + Filière
Formation

! Les terminaisons d’associations comme les attributs sont des

propriétés structurelles de la classe.

S. Mouline UML - Class Diagram 18

 Association entre classes (2)

! Propriété structurelle est paramètrée par :

! nom : appelé nom du rôle, il est situé à proximité de la
terminaison et est facultatif.
=> autant de noms de rôle que de terminaisons
! visibilité : mentionnée à proximité de la terminaison,
(éventuellement devant le nom de rôle)
! multiplicité : mentionnée à proximité de la terminaison et
facultative. Par défaut une terminaison d’association est
non spécifiée.
! navigabilité : peut être précisée (plus loin)

S. Mouline UML - Class Diagram 19

 Association entre classes (3) Sens de la lecture

S. Mouline UML - Class Diagram 20

 Association entre classes (4)
// Methods
Code en Java de la classe Personne
/** // Accessor methods
* Class Personne /**
*/ * Set the value of CIN
* @param newVar the new value of CIN
public class Personne {
*/
private void setCIN (String newVar) {
// CIN = newVar;
// Fields }
//
/**
* Get the value of CIN
private String CIN; * @return the value of CIN
private String Nom; */
private String Prénom; private String getCIN () {
private date Date_Naiss; return CIN;
}
…………….
public Formation m_filière;
/**
* Get the value of m_filière
// * @return the value of m_filière
// Constructors */
// public Formation getFilière () {
return m_filière;
public Personne () { };
}
}
S. Mouline UML - Class Diagram 21
 Association entre classes (5)
// Methods
Code en Java de la classe Formation
/** // Accessor methods
* Class Formation /**
*/ * Set the value of Ref
* @param newVar the new value of Ref
public class Formation {
*/
private void setRef (String newVar) {
// Ref = newVar;
// Fields }
//
/**
private String Ref; * Get the value of Ref
private String Nom; * @return the value of Ref
private String Spécialité; */
private String getRef () {
private String Niveau;
return Ref;
}
public Vector etudiantVector = new Vector(); …………….
/**
// * Get the List of Etudiant objects held by etudiantVector
// Constructors * @return List of Etudiant objects held by etudiantVector
// */
public Formation () { }; public List getEtudiantList () {
return (List) etudiantVector;
}
}
S. Mouline UML - Class Diagram 22
 Association entre classes (6)

Cours
*

Etudiant * 0..1 Enseignant

tuteur
inscription

S. Mouline UML - Class Diagram 23

 Association entre classes (7)
import java.util.*;

/**
* Class Personne
*/
public class Personne {
// Fields
//

private String CIN;

private String Nom;
private String Prénom;
private date Date_Naiss;
private Personne Mère;

public Formation m_filière;

……
}
S. Mouline UML - Class Diagram 24
 Association entre classes (7)
La navigabilité

! Sens de l’association. Par défaut, une association

est navigable dans les deux sens.

S. Mouline UML - Class Diagram 25

 Association entre classes (7)
La navigabilité
import java.util.*;
/** import java.util.*;
* Class Formation
*/
public class Formation { /**
// Fields * Class Module
*/
//
public class Module {
private String Ref;
private String Nom; //
private String Spécialité; // Fields
private String Niveau; //

private String Ref;

public Vector etudiantVector = new Vector();
private String Nom;
public Vector moduleVector = new Vector(); private Integer Semestre;
… …
}
}

S. Mouline UML - Class Diagram 26

 Agrégation et composition
! Agrégation : concept de "est une partie de".
# Difficulté : différence entre agrégation et association.
• Dans l'UML : idée pas complètement définie : sans
sémantique ("placebo")
# Définition d'une variété d'agrégation : la composition
$ L'objet "partie" ne peut appartenir qu'à un seul "tout"
$ Les parties sont créées et meurent avec le tout : la destruction du tout se
propage en cascade aux parties.
$ Impliquée par tout extrémité d'association ayant une multiplicité 1..1
(destruction d'un Client implique celle de toutes ses commandes et donc
celle des lignes de commande)

S. Mouline UML - Class Diagram 27

 Diagrammes de classe : concepts avancés

! Agrégation et composition :exemple

Contrainte
{ordered} Composition

Aggregation

S. Mouline UML - Class Diagram 28

 Généralisation et héritage (1)
! Dans le langage UML, la relation de généralisation se traduit
par le concept d’héritage.
! Nommée également relation d’héritage.

! Elle permet la classification des objets.

S. Mouline UML - Class Diagram 29

 Généralisation et héritage (2)
Généralisation

Vocabulaire :
●
La classe Utilisateur est une
généralisation des classes Enseignant et
Etudiant.
●
Les classes Enseignant et Etudiant sont
des spécialisation de la classe
Utilisateur

S. Mouline UML - Class Diagram 30

 Généralisation et héritage (3)

S. Mouline UML - Class Diagram 31

 Généralisation et héritage (4)
public class Utilisateur {

// Fields //
// private String CIN; // Other methods
private String Nom; //
private String Prénom;
private Date Date_Naiss; /**
private String e_mail; * @param cin
* @param nom
// Constructors * @param prénom
// * @param ddn
public Utilisateur () { }; */
// Methods public static void Créer(String cin, String nom, String
// Accessor methods prénom, Date ddn)
{
……. }

S. Mouline UML - Class Diagram 32

 Généralisation et héritage (5)

S. Mouline UML - Class Diagram 33

 Généralisation et héritage (6)
* Class Enseignant
*/
public class Enseignant extends Utilisateur //
{ // Other methods
//
//
// Fields /**
// * @param cin
* @param nom
private Date Date_emb; * @param prénom
private String Grade; * @param ddn
private String Département; * @param demb
* @param grade
// * @param dept
// Constructors */
// public static void Créer(String cin, String nom, String
public Enseignant () { }; prénom, Date ddn, Date demb, String grade, String dept)
// Methods {
// Accessor methods }
}
……. UML - Class Diagram
S. Mouline 34
 Généralisation et héritage (7)

Surcharge

S. Mouline UML - Class Diagram 35

S. Mouline UML - Class Diagram 36
 Opération abstraite

Méthode abstraite dont on connaît l’entête mais pas la

manière dont elle peut être réalisée

Méthode abstraite

Réalisées dans les

classes filles

S. Mouline UML - Class Diagram 37

 Classe abstraite

! Classe abstraite
! Contient au moins une opération abstraite
! Une classe mère contient une opération abstraite non
encore réalisée.
! Définie par le concepteur pour qu'elle soit non instanciable.

! Peut contenir des méthodes concrètes.

! Interface
! Classe abstraite pure qui ne comporte que des méthodes
abstraites.

S. Mouline UML - Class Diagram 38

 Classe active

! classe qui initie et contrôle le flux d’activités.

! Par défaut une classe est passive
! Représentation graphique :

« class »
Class_name

S. Mouline UML - Class Diagram 39

 Associations qualifiées

! Equivalent UML de : tableau associatif, "map" ou

dictionnaire
Ligne de commande
0..1
Commande Produit montant:Nombre
ligne

S. Mouline UML - Class Diagram 40

 Relation entre classes

! La généralisation et héritage
! L’association
! Multiplicité ou cardinalité
! Navigabilité
! Qualification
! Classe-association
! Agrégation et composition
! Dépendance

S. Mouline UML - Class Diagram 41

 Classe-association

! Une personne ne peut travailler que dans une entreprise

employeur
Personne * Entreprise
0..1

Emploi Classe-association
période:IntervalleDate

Emploi
1 0..1 * 1
Personne période:IntervalleDate Entreprise

/employeur

S. Mouline UML - Class Diagram 42

 Classe-association
! Avantage : il ne peut y a voir qu'une seule instance pour un
lien entre deux objets quelconques
! Une personne peut travailler dans plusieurs entreprises en même
temps mais elle ne peut pas avoir plus d'un emploi dans la même
entreprise

* employeur
Personne Entreprise
*

Emploi
période:IntervalleDate

Emploi
1 * * 1
Personne période:IntervalleDate Entreprise

/employeur

S. Mouline UML - Class Diagram 43

 Relation entre classes

! La généralisation et héritage
! L’association
! Multiplicité ou cardinalité
! Navigabilité
! Qualification
! Classe-association
! Agrégation et composition
! Dépendance

S. Mouline UML - Class Diagram 44

 Dépendante
! Relation unidirectionnelle qui exprime une dépendance
sémantique entre les éléments du modèle.
! " modification de la cible => une modification de la source

! Représentée par un trait discontinu orienté

Emploi du temps Cours

S. Mouline UML - Class Diagram 45

 Interfaces

! Une des propriétés importantes du modèle objet : faire

varier les implémentations des classes indépendamment
des interfaces

InputStream "interface"
DataInput

DataInputStream LectureCde

Réalisation Dépendance

S. Mouline UML - Class Diagram 46

 Diagrammes d ’objets

EstAcceptéPar>
: Distributeur
: CarteBleue
signataire

titulaires
cl1 : Client c4 : Compte : Banque : Consortium

: CarteBleue
signataire

cl2 : Client c1 : Compte : Banque

titulaires

titulaires
cl3 : Client c2 : Compte : Consortium
titula
ires

titulaires
cl4 : Client c3 : Compte : Banque

signataire
: CarteBleue
EstAcceptéPar>
cl5 : Client : Distributeur
EstAcceptéPar>

S. Mouline UML - Class Diagram 47