La modélisation objet consiste à créer une représentation abstraite, sous forme d'objets, d'entités ayant une existence matérielle (arbre, personne, téléphone, ...) ou bien virtuelle (sécurité sociale, compte bancaire, ...).
Un objet est caractérisé par plusieurs notions:
- Les attributs (on parle parfois de propriétés): Il s'agit des données caractérisant l'objet. Ce sont des variables stockant des informations d'état de l'objet
- Les méthodes (appelées parfois fonctions membres): Les méthodes d'un objet caractérisent son comportement, c'est-à-dire l'ensemble des actions (appelées opérations) que l'objet est à même de réaliser. Ces opérations permettent de faire réagir l'objet aux sollicitations extérieures (ou d'agir sur les autres objets). De plus, les opérations sont étroitement liées aux attributs, car leurs actions peuvent dépendre des valeurs des attributs, ou bien les modifier
- L'identité: L'objet possède une identité, qui permet de le distinguer des autres objets, indépendamment de son état. On construit généralement cette identité grâce à un identifiant découlant naturellement du problème (par exemple un produit pourra être repéré par un code, une voiture par un numéro de série, ...)
UML propose une manière de représenter les objets de façon graphique, sous forme de rectangle, dans lequel le nom de l'objet est souligné.
Les attributs (propriétés) d'un objet représentent ses caractéristiques.
L'ensemble des valeurs des attributs d'un objet constituent son état. UML propose
de représenter les attributs d'un objet et les valeurs associées de la manière
suivante:
Dans l'approche objet, les objets ne sont pas des corps inertes isolés. Bien au contraire, même
s'ils possèdent leurs caractéristiques propres par l'intermédiaire des valeurs de leurs
attributs (ce qui constitue ce que l'on appelle l'état), ils ont la possibilité d'interagir entre-eux grâce
à leurs méthodes. UML propose de représenter les liens qui existent entre les
objets grâce à un trait continu.
Un lien existe dès lors qu'un objet possède une visibilité vis-à-vis
d'un autre, c'est-à-dire lorsqu'un objet a un rapport direct avec un autre (appartenance,
utilisation, communication, ...).
Il est de plus possible d'ajouter des commentaires sur le modèle sous forme de notes.
Une note est représentée par un rectangle dont le coin supérieur droit
est replié. Pour relier une note à un objet il faut utiliser un trait discontinu
(en pointillés).
On appelle classe la structure d'un objet, c'est-à-dire la déclaration de l'ensemble des entités qui composeront un objet.
Un objet est donc "issu" d'une classe, c'est le produit qui sort d'un moule. En réalité on dit qu'un objet est une instanciation d'une classe,
c'est la raison pour laquelle on pourra parler indifféremment d'objet ou d'instance (éventuellement d'occurrence).
Une classe est composée:
- d'attributs: il s'agit des données, dont les valeurs représentent l'état de l'objet
- Les méthodes : il s'agit des opérations applicables aux objets
Si on définit la classe voiture, les objets Peugeot 406, Volkswagen Golf seront des instanciations
de cette classe. Il pourra éventuellement exister plusieurs objets Peugeot 406, diférenciés par leur numéro de série.
Mieux: deux instanciations de classes pourront avoir tous leurs attributs égaux sans pour autant être un seul et même objet
(c'est la différence entre état et identité). C'est le cas dans le monde réél, deux
T-shirts peuvent être strictement identique (avoir le même état) et pourtant ils sont distincts (ils ont chacun
leur identité propre). D'ailleurs en les mélangeant il serait impossible de les distinguer...
Une classe se représente avec UML sous forme d'un rectangle divisé en trois sections.
Le premier contient le nom donné à la classe (non souligné).
Les attributs d'une classe sont définis par un nom, un type (éventuellement une valeur par défaut, c'est-à-dire
une valeur affectée à la propriété lors de l'instanciation) dans le second compartiment.
Les opérations sont répertoriées dans le troisième volet du rectangle.
L'un des principaux concepts du paradigme objet est l'encapsulation.
L'encapsulation est un mécanisme consistant à rassembler les données et les méthodes au sein d'une structure en cachant l'implémentation de l'objet,
c'est-à-dire en empêchant l'accès aux données par un autre moyen que les services proposés.
L'encapsulation permet donc de garantir l'intègrité des données contenues dans l'objet.
En effet, la programmation orientée objet permet de cacher l'implémentation d'un objet
en ne lui permettant d'accèder aux attributs uniquement par l'intermédiaire de méthodes
crées à cet effet (on parle d'interface).
Il est ainsi possible de définir des niveaux d'encapsulation, afin de définir le type de classe
ayant accès aux attributs.
On parle de niveau de visibilité des éléments
de la classe. Ces niveaux de visibilité définissent les droits d'accès aux
données selon que l'on y accède par une méthode de la classe elle-même, d'une
classe héritiére, ou bien d'une classe quelconque. Il existe
trois niveaux de visibilité
- publique: Les fonctions de toutes les classes peuvent accéder aux données ou
aux méthodes d'une classe définie avec le niveau de visibilité public. Il s'agit
du plus bas niveau de protection des données
- protégée: l'accès aux données est réservé aux fonctions des classes
héritieres, c'est-à-dire par les fonctions membres de la classe ainsi que des
classes dérivées
- privée: l'accès aux données est limité aux méthodes de la classe elle-même. Il
s'agit du niveau de protection des données le plus élevé
La notation UML permet de représenter le niveau de visibilité des attributs de façon graphique
en faisant précéder le nom de chaque attribut par un caractère représentant la visibilité:
- + défini un attribut public
- # défini un attribut protégé
- - défini un attribut privé
|