Année Académique 2023-2024
COURS GENIE LOGICIEL
L2
Avril 2024
Enseignant : Dr. KOPOIN N’Diffon Charlemagne
Contacts : 0749950512 / 0153979792
Génie Logiciel
CHAPITRE 4:
MODELISATION AVEC UML
Page 2 sur 12
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
Table des matières
❖ Pré-requis .................................................................................................................................................... 4
❖ Objectifs Généraux ..................................................................................................................................... 4
❖ Objectifs du chapitre .................................................................................................................................. 4
1. Introduction ....................................................................................................................................................... 5
2. Notions : Méthode, Modèle, Langage et Diagramme ....................................................................................... 5
3. Les éléments et mécanismes généraux .............................................................................................................. 6
4. Diagrammes d’UML ......................................................................................................................................... 9
5. Paquetage ou Packages ................................................................................................................................... 11
Références............................................................................................................................................................... 12
Page 3 sur 12
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
❖ Pré-requis
➢ Connaissance générale sur les techniques de modélisation
➢ Connaissance générale sur les logiciels
❖ Objectifs Généraux
L’objectif principal de ce cours est d’initier les étudiants, à la conception des applications
informatiques de façon systématique (méthodique) et reproductible (rééditable); en les
incitant à rechercher et établir les fonctionnalités d'une application, et à les modéliser sous
forme de cas d'utilisation et de scénarios ainsi que rechercher les classes et les acteurs
nécessaires à la conception de l'application. Et, d’une manière spécifique ce cours vise à :
➢ Acquérir aux étudiants qui auront suivi ce cours, les bonnes pratiques de conception,
comme l'utilisation de patron de conception (design pattern), le découpage en
couches de l’architecture, la structuration en paquetages et le maquettage ;
➢ Maîtriser des techniques de génie logiciel, en se focalisant sur les approches par
objets et par composants ;
➢ Présenter un aperçu de l'état de l'art en matière de génie logiciel. .
➢ Proposer un ensemble de pratiques pragmatiques qui permettent de survivre à un
projet de développement de logiciel.
❖ Objectifs du chapitre
Ce chapitre aborde la modélisation de processus de développement logiciel avec le langage
UML
➢ Maitriser les concepts clés du langage UML ;
➢ Connaitre les étapes de modélisation avec UML
Page 4 sur 12
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
1. Introduction
UML (Unified Modeling Language) est un langage visuel standard utilisé en génie logiciel
pour décrire, spécifier, concevoir et documenter des systèmes logiciels. C'est une collection de
notations graphiques et de techniques de modélisation qui aident les développeurs de logiciels
et les parties prenantes à visualiser, communiquer et comprendre les systèmes logiciels.
UML est le résultat de la fusion de trois méthodes d’analyse orientées objet :
• La méthode OOD, Object Oriented Design, de G.Booch. Elle a été conçue à la demande
du Ministère de la Défense des USA. Elle définit 7 types de diagrammes pour
représenter un système orienté objet,
• La méthode OMT, Object Modeling Technique, a été mise au point à General Electric.
Elle décrit le système sous forme de vues statiques, dynamiques et fonctionnelles ;
• La méthode OOSE, Object Oriented Software Engineering, (Origine : universitaire
(informatique temps réel) et industrielle (Ericsson)). Elle Met l'accent sur l'analyse
fondée sur les cas d'utilisation.
UML est largement utilisé dans les projets de développement de logiciels comme moyen de
communication entre les développeurs, les concepteurs et les parties prenantes. Il aide à
identifier et à clarifier les exigences du système logiciel, ainsi qu'à concevoir et documenter
son architecture et son comportement.
2. Notions : Méthode, Modèle, Langage et Diagramme1
La construction d’un système d’information, d’un réseau, d’un logiciel complexe, de taille
importante et par de nombreuses personnes oblige à modéliser.
• La modélisation est une technique d’ingénierie qui permet de comprendre un système
par l’établissement de modèles pour mettre au point une solution à un problème.
• Un modèle est une abstraction permettant de mieux comprendre un objet complexe
(bâtiment, économie, atmosphère, cellule, logiciel, etc.). En informatique, un modèle
sert :
✓ De document d’échange entre clients et développeurs
✓ D’outil de conception
1
https://home.mis.u-picardie.fr/~furst/docs/1-UML_Besoins.pdf
Page 5 sur 12
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
✓ De référence pour le développement
✓ De référence pour la maintenance et l’évolution
• Langage de modélisation : une syntaxe commune, graphique, pour modéliser.
• Méthode : procédé permettant de construire un modèle aussi correct que possible et
aussi efficacement que possible (MERISE, …).
• Un diagramme est la représentation graphique d’un modèle.
3. Les éléments et mécanismes généraux
La modélisation orientée objet est une approche qui permet de structurer le code en utilisant
des concepts issus du monde réel, tels que les objets, les classes, les attributs et les méthodes.
Le tableau suivant présente les concepts de base et les mécanismes généraux de la modélisation
orientée objet :
Concepts de bases
Concept Description Exemple
Objet - Un objet est une entité
identifiable du monde réel.
- Il peut avoir une existence
physique (une chaise, une
voiture, un client, etc.) ou ne pas
en avoir (une commande).
- Identifiable signifie que l´objet
peut être désigné.
- Tout objet a un ensemble
d´attributs et un ensemble de
méthodes. Source: [2]
Classe Une classe décrit un groupe d’objets Cette classe s'appelle "Person" et a trois
ayant : attributs : "id", "name" et "age".
- les mêmes propriétés (attributs),
- un même comportement La classe possède également plusieurs
(opérations), et une sémantique méthodes pour accéder et modifier ces
commune (domaine de attributs.
définition).
2
Gabay, Joseph, and David Gabay. UML 2 Analyse et conception: Mise en œuvre guidee
avec etudes de cas. Dunod, 2008
Page 6 sur 12
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
Attribut - Un attribut est une propriété
élémentaire d’une classe.
- Pour chaque objet d’une classe,
l’attribut prend une valeur (sauf
cas d’attributs multivalués)
Opération
- Une opération est une fonction
applicable aux objets d’une
classe.
- Elle permet de décrire le
comportement d’un objet.
- Une méthode est
l’implémentation d’une
opération.
Mécanismes généraux
Mécanisme description Exemple
Encapsulation Les attributs sont représentés avec un tiret
L'encapsulation est un principe de devant leur nom pour indiquer qu'ils sont
l´approche orientée objet qui privés.
consiste à regrouper les données
(attributs) et les méthodes qui les Les méthodes commençant par un "+" sont
manipulent au sein d'une même des méthodes publiques, c'est-àdire qu'elles
classe, afin de les protéger contre les peuvent être appelées à partir de l'extérieur
accès non autorisés. de la classe.
Le constructeur de la classe prend trois
arguments : id, name et age. Les méthodes
setId(), setName() et setAge() sont utilisées
pour définir les valeurs des attributs privés.
Page 7 sur 12
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
Héritage
L'héritage est un mécanisme de
l´approche objet qui permet de créer
une nouvelle classe en utilisant une
classe existante comme modèle. La
nouvelle classe hérite des attributs et
des méthodes de la classe parente.
- Dans cet exemple, la classe Forme est la
classe parente qui contient une méthode
surface() qui calcule la surface de la
forme.
- Les classes Rectangle et Cercle héritent de
la classe Forme et ajoutent des attributs
spécifiques : longueur et largeur pour
Rectangle, et rayon pour Cercle.
Polymorphisme Dans l´exemple précédent, les classes
Le polymorphisme signifie que la Rectangle et Cercle peuvent également
même méthode peut avoir des redéfinir la méthode calculerSurface() pour
comportements différents dans des calculer la surface spécifique à leur forme. La
classes différentes. flèche creuse indique que Rectangle et Cercle
héritent de la classe Forme.
Abstraction L'abstraction est un principe de
l´approche objet qui consiste à définir
des interfaces claires et simples pour
les classes et les objets, afin de
masquer la complexité interne et de
faciliter l'utilisation du code.
Page 8 sur 12
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
4. Diagrammes d’UML
UML fournit un ensemble de diagrammes normalisés qui peuvent être utilisés pour représenter
différents aspects d'un système logiciel, tels que les exigences, la structure, le comportement et
les interactions entre les composants. Les créateurs d'UML ont organisé les diagrammes en
fonction de trois axes pour orienter leurs modélisations (Figure suivante3) :
- L'axe fonctionnel représente les actions effectuées par le système à construire.
- L'axe structurel et statique décrit la configuration du système.
- L'axe dynamique se concentre sur la construction des fonctionnalités du système.
Figure 1: Les axes d´UML
UML 2.0 offre divers types de diagrammes permettant de représenter graphiquement et de gérer
les différents éléments de la modélisation (figure 2) :
• Le diagramme des cas d’utilisation : représente les fonctionnalités (ou dit cas
d’utilisation) nécessaires aux utilisateurs.
3
Roques, Pascal. UML 2 par la pratique: Etudes de cas et exercices corriges. Editions Eyrolles,
2008.
Page 9 sur 12
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
• Diagramme de classes : dans la phase d’analyse, ce diagramme représente les entités
(des informations) manipulées par les utilisateurs. Dans la phase de conception, il
représente la structure objet d’un développement orienté objet.
• Le diagramme d’objet : sert à illustrer les classes complexes en utilisant des exemples
d’instances. Une instance est un exemple concret de contenu d’une classe. En illustrant
une partie des classes avec des exemples (grâce à un diagramme d’objets), on arrive à
voir un peu plus clairement les liens nécessaires.
Figure 2: Les diagrammes UML dans le processus de développement
• Le diagramme de séquences : permet de décrire les différents scénarios d’utilisation
du système.
• Le diagramme d’activités : représente le déroulement des actions, sans utiliser les
objets. En phase d’analyse, il est utilisé pour consolider les spécifications d’un cas
d’utilisation.
• Le diagramme de collaboration (appelé également diagramme de communication)
: Il permet de mettre en évidence les échanges de messages entre objets. Cela nous aide
à voir clair dans les actions qui sont nécessaires pour produire ces échanges de
messages. Et donc de compléter, si besoin, les diagrammes de séquence et de classes.
• Le diagramme état-transition : Il permet de décrire le cycle de vie des objets d’une
classe.
Page 10 sur 12
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
• Le diagramme global d’interaction : permet de donner une vue d’ensemble des
interactions du système. Il est réalisé avec le même graphisme que le diagramme
d’activité. Chaque élément du diagramme peut ensuite être détaillé à l’aide d’un
diagramme de séquence ou d’un diagramme d’activité.
• Le diagramme de temps : est destiné à l’analyse et la conception de systèmes ayant
des contraintes temps-réel. Il s’agit là de décrire les interactions entre objets avec des
contraintes temporelles fortes.
• Le diagramme de structure composite : décrit un objet complexe lors de son
exécution.
• Le diagramme de composants : décrit tous les composants utiles à l’exécution du
système (applications, librairies, instances de base de données, exécutables, etc.).
• Le diagramme de déploiement : correspond à la description de l’environnement
d’exécution du système (matériel, réseau…) et de la façon dont les composants y sont
installés.
5. Paquetage ou Packages
Un Paquetage (sous modèle) : c’est une notion qui peut apparaître dans beaucoup de
diagrammes pour spécifier le regroupement d’éléments au sein d’un sous-système (cas, classes,
objets, composants, autres paquetages, ...) et aussi pour encapsuler ces éléments.
Caractéristiques d’un paquetage :
• Les packages peuvent contenir des éléments tels que des classes, des interfaces, des
diagrammes, des sous-packages, des commentaires et des contraintes.
• Les packages peuvent être organisés en une hiérarchie, ce qui permet de définir des
relations d'importation et de dépendance entre eux.
• Les packages peuvent être nommés et utilisent une notation de nommage en point pour
refléter leur position dans la hiérarchie.
• Les packages peuvent être utilisés pour encapsuler des éléments, ce qui permet de
définir leur portée et leur visibilité dans le modèle.
• Les packages peuvent également être utilisés pour représenter des groupes fonctionnels
ou des sous-systèmes, ce qui permet de mieux comprendre la structure et les
interactions du système dans son ensemble.
Page 11 sur 12
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
• Les éléments contenus dans un paquetage doivent représenter un ensemble fortement
cohérent et sont généralement de même nature et de même niveau sémantique.
Généralement, il existe un seul paquetage racine qui détient la totalité du modèle d’un
système.
Les packages sont un élément important de la modélisation UML, car ils permettent de gérer
la complexité des modèles en les organisant en unités logiques plus grandes et plus cohérentes.
Références
[1] L. DJAKHDJAKHA, « Génie Logiciel », 2023, Consulté le: 2 avril 2024. [En ligne].
Disponible sur: https://dspace.univ-
guelma.dz/jspui/bitstream/123456789/14843/1/polycopie%20de%20cours%20genie%20l
ogiciel%20%20Djakhdjakha%20lynda.pdf
Page 12 sur 12
Dr. N’Diffon Charlemagne KOPOIN / Assistant en Informatique-IA à ESATIC
