Diagramme de classes
Cet article est une ébauche concernant l’informatique.
Vous pouvez partager vos connaissances en l’améliorant (comment ?) selon les recommandations des projets correspondants.
Le diagramme de classes est un schéma utilisé en génie logiciel pour présenter les classes et les interfaces des systèmes ainsi que leurs relations. Ce diagramme fait partie de la partie statique d'UML, ne s'intéressant pas aux aspects temporels et dynamiques.
Une classe décrit les responsabilités, le comportement et le type d'un ensemble d'objets. Les éléments de cet ensemble sont les instances de la classe.
Une classe est un ensemble de fonctions et de données (attributs) qui sont liées ensemble par un champ sémantique. Les classes sont utilisées dans la programmation orientée objet. Elles permettent de modéliser un programme et ainsi de découper une tâche complexe en plusieurs petits travaux simples.
Les classes peuvent être reliées grâce au mécanisme d'héritage qui permet de mettre en évidence des relations de parenté. D'autres relations sont possibles entre des classes, représentées par un arc spécifique dans le diagramme de classes.
Elles sont finalement instanciées pour créer des objets (une classe est un moule à objet : elle décrit les caractéristiques des objets, les objets contiennent leurs valeurs propres pour chacune de ces caractéristiques lorsqu'ils sont instanciés).
Schéma d'une classe
[modifier | modifier le code]
Une classe est représentée par un rectangle séparé en trois parties :
- la première partie contient le nom de la classe
- la seconde contient les attributs de la classe
- la dernière contient les méthodes de la classe
La seconde et la dernière représentent le comportement de la classe.
Première partie : le nom de la classe
[modifier | modifier le code]
Il est écrit dans le rectangle du haut.
Dans une classe classique, le nom est écrit en romain (exemple : « ClasseClassique »).
Le nom des classes abstraites est écrit en italique (exemple : ClasseAbstraite).
Les classes template ont, dans leur angle supérieur droit, un rectangle dont la bordure est en pointillé et qui contient les types des paramètres.
Seconde partie : les attributs
[modifier | modifier le code]La syntaxe d'un attribut est la suivante :
Visibilité nomAttribut [multiplicité] : typeAttribut = Initialisation ;
Visibilité
[modifier | modifier le code]La notion de visibilité indique qui peut avoir accès à l'attribut.
Elle ne peut prendre que quatre valeurs :
| Caractère | Rôle | Mot clé | Description |
|---|---|---|---|
| + | accès public | public | Toutes les autres classes ont accès à cet attribut. |
| # | accès protégé | protected | Seules la classe elle-même et les classes filles (héritage) ont accès à cet attribut. |
| ~ | accès package | package | Classe visible uniquement dans le package. |
| - | accès privé | private | Seule la classe elle-même a accès à cet attribut. |
Afin de respecter le principe fondamental d'encapsulation, tous les attributs devraient être privés.
Pour qu'un attribut privé ou protégé soit récupérable, on utilise en général un getter (ou accesseur); pour qu'il soit modifiable, on utilise en général un setter (ou mutateur).
Nom
[modifier | modifier le code]Il ne doit pas comporter d'espaces, de signes de ponctuation ou d'accents. Pour remplacer les espaces, plusieurs conventions existent : on peut intercaler un symbole _ entre les mots ou utiliser la méthode CamelCase qui consiste à mettre la première lettre de chaque mot en capitale (par exemple, nom de l'objet peut devenir : nom_objet ou NomObjet).
Multiplicité
[modifier | modifier le code]La multiplicité représente le nombre de fois où la variable peut intervenir. Elle est représentée entre crochets.
Par exemple, si une personne possède deux numéros de téléphone, on préfèrera noTelephones[2] à noTelephone1 et noTelephone2.
Exemple
[modifier | modifier le code]//attribut public prenom de type string (chaine de caractères)
+ prenom : string
//attribut privé age de type int (entier)
- age : int
Troisième partie : les méthodes
[modifier | modifier le code]La syntaxe d'une méthode est la suivante :
Visibilité nomFonction(directionParamètreN nomParamètreN : typeParamètreN) : typeRetour
Visibilité
[modifier | modifier le code]La notion de visibilité est la même que celle des attributs.
Direction du paramètre
[modifier | modifier le code]Indique si le paramètre est rentrant (in), s'il est sortant (out) ou s'il est rentrant et sortant (inout).
Exemples de méthode
[modifier | modifier le code]//méthode publique getAge() retournant un entier
+ getAge() : int
//méthode protégée calculerAge() prenant comme paramètre dateNaissance de type Date et ne retournant rien (void)
# calculerAge(in dateNaissance : Date) : void
Relations entre les classes
[modifier | modifier le code]Ces relations ne sont pas propres aux diagrammes de classes, elles peuvent également s'appliquer à l'ensemble des diagrammes statiques.
Héritage
[modifier | modifier le code]
L'héritage est un principe de division par généralisation et spécialisation, représenté par un trait reliant les deux classes et dont l'extrémité du côté de la classe mère comporte un triangle.
La classe fille hérite de tous les attributs et méthodes, qu'ils soient publics, protégés ou privés. Cependant, elle ne peut pas utiliser directement les attributs et méthodes privés (que ce soit en lecture ou en écriture), sauf par l'intermédiaire d'une méthode héritée (publique ou protégée).
Association
[modifier | modifier le code]
1- Bidirectionnelle
2- Mono-directionnelle, Invocation de méthode
3- interdit une association.
L'association est une connexion sémantique entre deux classes (relation logique). Une association peut être nommée. L'invocation d'une méthode est une association. Elle peut être binaire, dans ce cas elle est représentée par un simple trait, ou n-aire, les classes sont reliées à un losange par des traits simples. Ces relations peuvent être nommées. L'association n'est utilisée que dans les diagrammes de classe.
- multiplicité : comparable aux cardinalités du système Merise, sert à compter le nombre minimum et maximum d'instances de chaque classe dans la relation liant 2 ou plusieurs classes.
- navigabilité : les associations sont bidirectionnelles et peuvent être parcourues dans les 2 sens. Lorsque l’association est contrainte pour devenir unidirectionnelle, le sens de navigation qui reste possible est spécifié par une flèche.
Il est préférable de laisser les associations bidirectionnelles. UML autorise d’alerter sur le sens de la navigation interdit avec une croix en plus de la flèche.
Agrégation
[modifier | modifier le code]
L'agrégation est une association avec relation de subordination, représentée par un trait reliant les deux classes et dont l'origine se distingue de l'autre extrémité (la classe subordonnée) par un losange vide. Une des classes regroupe d'autres classes. L'objet T utilise une instance de la classe T'.
Composition
[modifier | modifier le code]
La composition est une agrégation avec cycle de vie dépendant : la classe composante est détruite lorsque la classe composée (ou classe composite) disparaît. L'origine de cette association est représentée par un losange plein. L'objet T' est composé de T.
Dépendance
[modifier | modifier le code]Implique qu'une ou plusieurs méthodes reçoivent un objet d'un type d'une autre classe. Il n'y a pas de liaison en ce qui concerne la destruction d'objets mais une dépendance est quand même là. Elle est symbolisée par une flèche en pointillés, dont son extrémité possède trois traits qui se coupent en un même point.
Exemple de code
[modifier | modifier le code]Certains logiciels IDE permettent de générer automatiquement le code source correspondant au diagramme de classes.
Le code source Java suivant correspond au schéma UML de Animal, Chat et Animalerie :
/* Déclaration des classes */
public class Animal
{
/**
* Nom de l'Animal
*/
protected String nom;
/**
* Cri de l'Animal
*/
protected Son cri;
/**
* Constructeur de la classe Animal
*/
public Animal(String nom, String sonChemin) {
this.nom = nom;
this.cri = new Son(sonChemin);
}
/**
* Returne le Nom de l'Animal
*/
public String nom(){
return this.nom;
}
/**
* Returne le cri de l'Animal
*/
public Son cri(){
return this.cri;
}
}
public class Son
{
/**
* Nom du fichier son
*/
private String nomFichier;
/**
* Constructeur
*/
public Son(String fichier)
{
this.nomFichier = fichier;
}
/**
* Permet une lecture du Son
*/
public void lire() { ... }
/**
* Arrete la lecture du Son
*/
public void stop() { ... }
}
public class Chat extends Animal //Héritage
{
/**
* Constructeur
*/
public Chat(String nom)
{
super(nom, "miaulement.ogg"); //Appel du Constructeur d'Animal
}
}
public class Animalerie
{
/**
* Liste de tous les Animaux
*/
private LinkedList<Animal> members;
/**
* Constructeur
*/
public Animalerie(){
this.members = new LinkedList<Animal>(); //Agrégation
}
/**
* Ajout d'un Animal dans l'Animalerie
*/
public void ajouteAnimal(Animal monanimal) {
members.add(monanimal);
}
};
Voir aussi
[modifier | modifier le code]Articles connexes
[modifier | modifier le code]Liens externes
[modifier | modifier le code]- Laurent Audibert, « Chapitre 3 Diagramme de classes », sur developpez.com
