3 UML Diag Classes

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 Licence SMI-FSR Mod. 31 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é

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

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.

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).
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).

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} …).

Attribut dérivé
 Attributs dérivés d'autres attributs
Personne
dateNaiss
/âge
/âge=dateCourante_dateNaiss

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()

 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),
…)

 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

 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
Accès à la valeur d'un attribut
getCNE() : String
setAdresse(adr : String) : void

Mise à jour de la valeur d'un attribut

Exemple de classe
Attributs
privés
Constructeurs
Accesseurs
Autre
opération

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

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

Exemple de classe
Attribut
de classe
Opération
de classe

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.

 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)

Association entre classes (3) Sens de la lecture

// 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 () {
public Personne () { }; return m_filière;
}
}
// 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;
}
}
Cours
*
Etudiant * 0..1 Enseignant

tuteur
inscription

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;

……
}
La navigabilité
 Sens de l’association. Par défaut, une association

est navigable dans les deux sens.

La navigabilité
import java.util.*;
/** import java.util.*;
* Class Formation
*/
public class Formation { /**
* Class Module
// Fields
*/
//
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;
… …
}
}

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)

Diagrammes de classe : concepts avancés
 Agrégation et composition :exemple
Contrainte
{ordered} Composition
Aggregation

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.

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


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)
{
……. }


* 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 }
}
……. Licence SMI-FSR Mod. 31 UML - Class Diagram
S. Mouline 34
Surcharge

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

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.

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

Associations qualifiées
 Equivalent UML de : tableau associatif, "map" ou

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

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

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

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

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

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

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

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>

3 UML Diag Classes

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

3 UML Diag Classes

Transféré par

Droits d'auteur :

Formats disponibles

Diagramme de Classes

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 2

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 3

 Une classe est un concept abstrait qui représente

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 4

 Un objet est une instance d’une classe.

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 5

 Comportement d’un objet :

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

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

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

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

<visibilité> [/] <nom_attribut>:

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

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 8

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 9

 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

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

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 10

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

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 11

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 12

• Exemple pour la classe Etudiant :

setAdresse(adr : String) : void

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 13

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 14

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

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 15

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

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 16

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 17

1..* Inscrit dans 1

 Les terminaisons d’associations comme les attributs sont des

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 18

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

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 19

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 20

Etudiant * 0..1 Enseignant

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 23

private String CIN;

public Formation m_filière;

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

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 25

private String Ref;

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 26

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 27

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 28

 Elle permet la classification des objets.

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 29

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 30

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 31

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 32

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 33

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 35

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

Réalisées dans les

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 37

 Peut contenir des méthodes concrètes.

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 38

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

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 39

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

S. Mouline Licence SMI-FSR Mod. 31 UML - Class Diagram 40