Diagramme de classes

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 les différentes relations entre celles-ci. Ce diagramme fait partie de la partie statique d'UML car il fait abstraction des 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 liées entre elles 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, chacune de ces relations est représentée 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

Modèle d'une simple classe.

Une classe est représentée par un rectangle séparée 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

Première partie : le nom de la classe

Modèle d'une classe abstraite.

Modèle d'une classe template.

Il est écrit dans le rectangle du haut.

Dans une classe classique, le nom est écrit en normal.

Le nom des classes abstraites est écrit en italique.

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

La syntaxe d'un attribut est la suivante :

Visibilité nomAttribut [multiplicité] : typeAttribut = Initialisation

Visibilité

La notion de visibilité indique qui peut avoir accès à l'attribut.

Elle ne peut prendre que 3 valeurs possibles :

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, il faut utiliser un getter (ou accesseur); pour qu'il soit modifiable, il faut utiliser un setter (ou mutateur).

Nom de l'attribut

Il ne doit pas comporter ni espaces, ni signes de ponctuation, ni accents. A la place des espaces, il faut utiliser le symbole _ ou changer la première lettre du mot en majuscule (Exemple : nom de l'objet peut s'écrire nomObjet ou nom_Objet.

Multiplicité

La multiplicité représente le nombre de fois où la variable peut exister. Elle est représentée entre crochets.

Par exemple : si une personne possède 2 numéros de téléphone, on préfèrera noTelephones[2] à noTelephone1 et noTelephone2.

Exemple d'attributs

//attribut public prenom de type string (chaine de caracteres)

+ prenom : string

//attribut privé age de type int (entier)

- age : int

Troisième partie : les méthodes

La syntaxe d'une méthode est la suivante :

Visibilité nomFonction(directionParamètreN nomParamètreN : typeParamètreN) : typeRetour

Visibilité

La notion de visibilité est la même que celle des attributs.

Direction du paramètre

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

//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

Ces relations ne sont pas exclusives au diagramme de classe, elles peuvent également s'appliquer à l'ensemble des diagrammes statiques.

T' hérite de T

Héritage

Principe de division par généralisation et spécialisation, représenté par un trait reliant les deux classes et dont l'origine (classe mère) se distingue de l'autre extrémité (classe fille) par 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)

Navigabilité des associations
1- Bidirectionnelle
2- Mono-directionnelle, Invocation de méthode
3- interdit une association

Association

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-aires, 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é : indique si on pourra accéder d'une classe à l'autre. Si la relation est entre les classes A et B et que seulement B est navigable, alors on pourra accéder à B à partir de A mais pas vice versa. Par défaut, la navigabilité est dans les 2 sens.

Agrégation

Association avec relation de subordination, représentée par un trait reliant les deux classes et dont l'origine se distingue de l'autre l'extrémité (la classe subordonnée) par un losange. Une des classes "regroupe" d'autres classes. On peut dire que l'objet T utilise une instance de la classe T'.

Agrégation

Composition

Composition avec cycle de vie dépendant (on dit que la classe composée est détruite lorsque la classe mère disparait).

Composition

Dépendance

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

Exemple de 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
 {
   public String nom = "animal";
   protected double champProtected = 0;
   private boolean champPrive = false;
 
   public Animal() {}
   public void modifierNom(String newNom) { this.nom = newNom; }
 }
 
public class Son
 {
   private String nomFichier;
   public Son(String fichier)
    {
       this.nomFichier=fichier;
    };
   public void lire() {}                       //association avec la classe gérant les fichiers sons
   public void stop() {}
 }
 
 
public class Chat extends Animal                //Héritage
 { 
   public Son cri;                             //Composition, il y a destruction de l'instance cri lorsque l'instance Chat est détruite
   public Chat(String nom) 
    {
       modifierNom(nom);
       cri = New Son("miaulement.ogg");
    }
 }
 
public class Animalerie
{
  ...
  private LinkedList<Animal> members=new LinkedList<Animal>();              // Agrégation
  public void ajoute (Animal monanimal) {
      members.add(monanimal);
  }
  ...
};

Voir aussi

Exemple de diagramme de classe

Articles connexes

• Unified Modeling Language
• Programmation orientée objet
• Patron de conception

Liens externes

• (fr)Laurent Audibert, « Chapitre 3 Diagramme de classes » sur developpez.com

• Portail de l’informatique