Vous êtes sur la page 1sur 5

1 Introduction à la programmation orientée objet

1.1 Un nouveau concept de développement


«Au cours des 35 dernieres années, les concepteurs de matériel informatique sont passés de machine de la taille
d’un hangar à des ordinateurs portables légers basés sur de minuscules microprocesseurs.
Au cours des mêmes années, les développeurs de logiciel sont passés de l’écriture de programmes en assembleur
et en COBOL à l’écriture de programmes encore plus grands en C et C++. On pourra parler de progrès (bien que
cela soit discutable), mais il est clair que le monde du logiciel ne progresse pas aussi vite que celui du matériel.
Qu’ont donc les développeurs de matériel que les développeurs de logiciels n’ont pas ?
La réponse est donnée par les composants. Si les ingénieurs en matériel électronique devaient partir d’un tas de
sable à chaque fois qu’ils conçoivent un nouveau dispositif, si leur première étape devait toujours consister à
extraire le silicium pour fabriquer des circuits intégrés, ils ne progresseraient pas bien vite.
Or, un concepteur de matériel construit toujours un système à partir de composants préparés, chacun chargé
d’une fonction particulière et fournissant un ensemble de services à travers des interfaces définies. La tâche des
concepteurs de matériel est considérablement simplifiée par le travail de leurs prédécesseurs.
La réutilisation est aussi une vie vers la création de meilleurs logiciels.
Aujourd’hui encore, les développeurs de logiciels en sont toujours à partir d’une certaine forme de sable et à
suivre les mêmes étapes que les centaines de programmeurs qui les ont précédés. Le résultat est souvent
excellent, mais il pourrait être amélioré. La création de nouvelles applications à partir de composants existants,
déjà testés, a toutes les chances de produire un code plus fiable. De plus, elle peut se révéler nettement plus
rapide et plus économique, ce qui n’est pas moins important.»

1.1.1 La notion d’objet


La programmation orientée objet consiste à modéliser informatiquement un ensemble d’éléments d’une partie
du monde réel (que l’on appelle domaine) en un ensemble d’entités informatiques. Ces entités informatiques
sont appelées objets. Il s’agit de données informatiques regroupant les principales caractéristiques des éléments
du monde réel (taille, couleur,…).
L’approche objet est une idée qui a désormais fait ses preuves. Simula a été le premier langage de programmation
à implémenter le concept de classes en 1967. En 1976, Smalltalk implémente les concepts d’encapsulation,
d’agrégation, et d’héritage (les principaux concepts de l’approche d’objet). D’autre part, de nombreux langages
orientes objets ont été mis au point dans un but universitaire (Eiffel, Objectif C, Loops…)
La difficulté de cette modélisation consiste à créer une représentation abstraite, sous forme d’objets, d’entités
ayant une existence matérielle (chien, voiture, ampoule,…) ou bien virtuelle (sécurité sociale, temps,…).
Un objet est caractérise par plusieurs notions :
 Les attributs : 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,…)
1.1.2 La notion de classe
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 de deux parties :
 Les attributs (parfois appelés données membres) : Il s’agit des données représentant l’état de l’objet
 Les méthodes (parfois appelées fonctions membres) : Il s’agit des opérations applicables aux objets
Si on définit la classe voiture, les objets Peugeot 406, Renault 18 seront des instanciations de cette classe. Il
pourra éventuellement exister plusieurs objets Peugeot 406, différenciés par leur numéro de série. Mieux : deux
instanciations de classe pourront avoir tous leurs attributs égaux sans pour autant être un seul et même objet.
C’est le cas dans le monde réel, deux T-shirts peuvent être strictement identiques et pourtant ils sont distincts.
D’ailleurs en les mélangeant il serait impossible de les distinguer...

1.1.3 Les méthodes objets


La modélisation objet consiste à créer une représentation informatique des éléments du monde réel auxquels on
s’intéresse, sans se préoccuper de l’implémentation, ce qui signifie indépendamment d’un langage de
programmation. Il s’agit donc de déterminer les objets présents et d’isoler leurs données et les fonctions qui les
utilisent. Pour cela des methodes ont été mises au point. Entre 1970 et 1990, de nombreux analystes ont mis au
point des approches orientées objets, si bien qu’en 1994 il existait plus de 50 méthodes objet. Toutefois, seules 3
méthodes ont véritablement émergé :
 La méthode OMT de Rumbaugh
 La méthode BOOCH’93 de Booch
 La méthode OOSE de Jacobson
A partir e 1994, Rumbaugh et Booch (rejoints en 1995 par Jacobson) ont uni leurs efforts pour mettre au point le
langage de description UML (Unified Modeling Language), qui permet de définir un langage standard en
incorporant les avantages des différentes méthodes précédentes (ainsi que celles d’autres analystes). Il permet
notamment de « programmer » entièrement une application avec un langage qui modélise toutes les
composantes du futur programme.

1.2 Héritage
1.2.1 La notion d’héritage
L’héritage (en anglais inheritance) est un principe propre à la programmation orientée objet, permettant de créer
une nouvelle classe à partir d’une classe existante. Le nom d’héritage (pouvant parfois être appelé dérivation de
classe) provient du fait que la classe dérivée (la classe nouvellement créée) contient les attributs et les méthodes
de sa super-classe (la classe dont elle dérive). L’intérêt majeur de l’héritage est de pouvoir définir de nouveaux
attributs et de nouvelles méthodes pour la classe dérivée, qui viennent s’ajouter à ceux et celles héritées.
Par ce moyen on crée une hiérarchie de classes de plus en plus spécialisées. Cela a comme avantage majeur de ne
pas avoir à repartir de zéro lorsqu’on veut spécialiser une classe existante. De cette manière il est possible
d’acheter dans le commerce des librairies de classes, qui constituent une base, pouvant être spécialisées à loisir
(on comprend encore un peu mieux l’intérêt pour l’entreprise qui vend les classes de protéger les données
membres grâce à l’encapsulatio).

1.2.2 Hiérarchie des classes


Il est possible de présenter sous forme de hiérarchie de classes, parfois appelée arborescence de classes, la
relation de parenté qui existe entre les différentes classes. L’arborescence commence par une classe générale
appelée superclasse (parfois classe de base, classe parent, classe ancêtre, classe mère ou classe père, les
métaphores généalogiques sont nombreuses). Puis les classes dérivées (classe fille ou sous-classe) deviennent de
plus en plus spécialisées. Ainsi, on peut généralement exprimer la relation qui lie une classe fille à sa mère par la
phrase «est un» (de l’anglais «is a»).
Animal

Herbivore Carnivore Omnivore

Lapin Lion Hyène Homme

1.2.3 Héritage multiple


Certains langages orientés objet, tels que le C++, permettent de faire l’héritage multiple, ce qui signifie qu’ils
offrent la possibilité de faire hériter une classe de deux superclasses. Ainsi, cette technique permet de regrouper
au sein d’une seule et même classe les attributs et méthodes de plusieurs classes.

Animal

Herbivore Carnivore

Omnivore

1.3 Encapsulation
1.3.1 Le concept d’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.

1.3.2 Le masquage des informations


L’utilisateur d’une classe n’a pas forcement à savoir de quelle façon sont structurées les données dans l’objet,
cela signifie qu’un utilisateur n’a pas à connaitre l’implémentation. Ainsi, en interdisant l’utilisateur de modifier
directement les attributs, et en l’obligeant à utiliser les fonctions définies pour les modifier (appelées interfaces),
on est capable de s’assurer de l’intégrité des données (on pourra par exemple s’assurer que le type des données
fournies est conforme à nos attentes, ou encore que les données se trouvent bien dans l’intervalle attendu).
L’encapsulation permet de définir des niveaux 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 la 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éritières, 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é.

1.4 Polymorphisme
1.4.1 Définition du polymorphisme
Le nom de polymorphisme vient du grec et signifie qui peut prendre plusieurs formes. Cette caractéristique
essentielle de la programmation oriente objet la caractérise
On distingue généralement trois types de polymorphisme :
 Le polymorphisme ad hoc (également surcharge ou en anglais overloading)
 Le polymorphisme d’héritage (également redéfinition, spécialisation ou en anglais overriding)
 Le polymorphisme paramétrique (également généricité ou en anglais template)

Surcharge

Ad hoc

Polymorphisme paramétrique

Universel

Sous-type

Nous allons maintenant tenter de définir plus précisément tout cela, mais il est important de noter que beaucoup
de confusion existe lorsqu’il s’agit de différencier tous ces polymorphismes.

1.4.2 Le polymorphisme paramétrique


Le polymorphisme paramétrique, appelé généricité, représente la possibilité de définir plusieurs fonctions de
même nom mais possédant des paramètres différents (en nombre et/ou type). Le polymorphisme ad hoc rend
ainsi possible le choix automatique de la bonne méthode à adopter en fonction du type de donnée passée en
paramètre.
Ainsi, on peut par exemple définir plusieurs méthodes homonymes addition () effectuant une somme de valeurs.
 La méthode Int addition (Int, Int) pourra retourner la somme de deux entiers
 La méthode float addition (float, float) pourra retourner la somme de deux flottants
 La méthode char addition (char, char) pourra définir au gré de l’auteur la somme de deux caractères
 Etc.
On appelle signature le nombre et le type (statique) des arguments d’une fonction. C’est donc la signature d’une
méthode qui détermine quelle méthode sera appelée.
Le polymorphisme ad hoc permet ainsi de définir des opérateurs dont l’utilisation sera différente selon le type
des paramètres qui lui sont passés. Il est donc possible par exemple de surcharger l’operateur + et de lui faire
réaliser des actions différentes selon qu’il s’agit d’une opération entre deux entiers (addition) ou entre deux
chaines de caractères (concaténation).
1.4.3 Le polymorphisme ad hoc
Le polymorphisme ad hoc permet d’avoir des fonctions de même nom, avec des fonctionnalités similaires, dans
des classes sans aucun rapport entre elles (si ce n’est bien sûr d’être des filles de la classe objet). Par exemple, la
classe complexe, la classe image et la classe lien peuvent avoir une fonction afficher.
Cela permettant de ne pas avoir à se soucier du type de l’objet que l’on a si on souhaite l’afficher à l’écran.

1.4.4 Le polymorphisme d’héritage


Le polymorphisme d’héritage caractérise la possibilité de redéfinir une méthode dans des classes héritant d’une
classe de base. De cette façon il est possible d’appeler la méthode d’un objet sans se soucier de son type
intrinsèque.
Imaginons un jeu d’échec comportant des objets roi, reine, fou, cavalier, tour et pion, héritant chacun de l’objet
pièce.
La méthode mouvement () pourra, grâce au polymorphisme d’héritage, effectuer le mouvement approprie en
fonction de la classe de l’objet référencé au moment de l’appel. Cela permettra notamment au programme de
dire pièce. Mouvement sans savoir à se préoccuper de la classe de la pièce.

Vous aimerez peut-être aussi