LA PROGRAMMATION ORIENTEE OBJET (POO)
Objectifs :
- Introduire les notions d’encapsulation, d’abstraction, d’objets, d’instances et de classes
- Classes en C++
- Variables d’instance
- Méthodes d’instance
- Encapsulation et interface (public : et private :)
- L’objet this et le masquage
Exemples de langages orientés objets :
Smalltalk (Xerox, PARC, 1980)
Objective –C (Apple, Brad Cox, 1986)
Python (open source, Guido Van Rossum, 1990)
Java (Sun Micro system, 1995)
C # (Microsoft, 2001)
Par ailleurs, la plupart des langages non-objets admettent une extension objet. Tels que : Caml,
PERL, PHP, etc …
I. Avantages de la POO :
Façon naturelle de modéliser les données et traitements intervenant dans un programme.
Modularité : le programme est composé d’un ensemble d’entités (types d’objets) aux rôles
bien déterminés.
Réutilisabilité : chaque type d’objets peut être réutilisé, sa sémantique peut être étendue
par le biais de l’héritage.
Polymorphisme : un même code peut s’appliquer à des types d’objets différents.
Abstraction : la représentation des données est découplée de leur utilisation. De plus, des
règles précises d’utilisation des données peuvent être imposées.
D’énormes librairies déjà écrites (Java, C#). Ce qui permet une efficacité dans la
conception des programmes, concision du codage, meilleures fiabilité et maintenabilité des
programmes.
II. Concepts caractéristiques de la POO :
1. Notion d’encapsulation :
Le principe d’encapsulation consiste à regrouper dans le même objet informatique
« concept », données et traitements qui lui sont spécifiques :
o Les données incluses dans un objet seront appelées les attributs de cet objet,
o Les traitements/fonctions défini(e)s dans un objet seront appelées les méthodes de
cet objet.
Les objets sont définis par attributs et leurs méthodes : OBJET= attributs + méthodes
2. Notion d’abstraction des données :
Pour être véritablement intéressant, un objet doit permettre un certain degré d’abstraction.
Le processus d’abstraction consiste à identifier pour un ensemble d’éléments :
Des caractéristiques ( c-à-d attributs ) communes à tous les éléments
Des mécanismes (c-à-d methodes) communs à tous les éléments
1
Ceci permet de faire une description générique de l’ensemble considéré : se focaliser sur
l’essentiel, cacher les détails.
Les données ( attributs ou propriétés) sont manipulées à l’aide de méthodes qui cachent
leur représentation interne :
o On peut imposer que ces méthodes vérifient l’intégralité des données (fiabilité).
o L’utilisation d’une donnée ne dépend plus des choix faits pour sa représentation
(facilité de maintenance).
o Des données différentes peuvent être manipulées de manière identique (concision)
3. Notions de classe, d’objet et d’instance :
En programmation orientée objet :
- Le résultat du processus d’abstraction s’appelle une classe. Classe = catégorie d’objets
- Une classe définit un type (au sens du langage de programmation).
- Une réalisation particulière d’une classe s’appelle une instance. Une instance = un objet
EXEMPLE : Rectangle
La notion d’objet rectangle n’est intéressante que si l’on peut lui associer des propriétés
(attributs) et/ou mécanismes ( ou methodes) généraux. On s’intéresse ainsi aux
propriétés et mécanismes valables pour l’ensemble des rectangles et non pas pour un
rectangle particulier.
Les notions de largeur et hauteur sont des propriétés générales des rectangles (attributs).
Le mécanisme permettant de calculer la surface d’un rectangle (surface=largeur *
hauteur) est commun à tous les rectangles (méthodes).
Spécificité
h : 15 h : 30
h : 30
l : 26 l : 30
l : 12
S = 390 S = 900
S = 360
h:
l: Générique
S = h*l
Un intérêt de l’encapsulation est que cela permet d’abstraire :
En plus du regroupement des données et des traitements relatifs à une entité, l’encapsulation
permet en effet de définir deux niveaux de perception :
Le niveau externe : partie visible par les programmeurs-utilisateurs de l’objet (c’est-à-dire
le prototype des méthodes et attributs hors de l’objet. C’est l’interface.
Le niveau interne : détails d’implémentation de l’objet :
o Méthodes et attributs accessibles uniquement depuis l’intérieur de l’objet(ou
l’intérieur d’objets similaires).
o Définition de l’ensemble des méthodes de l’objet. C’est le corps de l’objet.
2
Rectangle : classe, objet (instance): // on veut instancier (créer) un type de rectangle
Rectangle
Classe (type abstrait)
Attributs : Méthodes :
largeur dessine()
hauteur surface()
Exemple Existence conceptuelle
(écriture du programme)
h : 30 Existence concrète
h : 30 h : 15
l : 26 l : 30 (exécution du programme)
l : 12
instance2 instance3
instance1
4. Pourquoi abstraire/encapsuler ?
L’intérêt de regrouper les traitements et les données conceptuellement reliés est de permettre une
meilleure visibilité et une meilleure cohérence au programme, d’offrir une plus grande
modularité
L’intérêt de séparer les niveaux interne et externe est de donner un cadre plus rigoureux à
l’utilisation des objets utilisés dans un programme.
Les objets ne peuvent être utilisés qu’au travers de leurs interfaces (niveau externe) et donc les
éventuelles modifications de la structure interne restent invisibles à l’extérieur. Même idée que la
séparation prototype/définition d’une fonction.
Règle du masquage : les attributs d’un objet ne doivent pas être accessibles depuis l’extérieur,
mais uniquement par des méthodes.
5. Encapsulation et interface :
Il y a donc deux facettes à l’encapsulation :
1er : regroupement de tout ce qui caractérise l’objet : données (attributs) et traitements (méthodes).
2e : isolement et dissimulation des détails d’implémentation interface.
Interface = ce que le programmeur-utilisateur (hors de l’objet) peut
utiliser.
Tout ceci permet la concentration sur les attributs/méthodes concernant l’objet (abstraction).
Exemple : l’interface d’une voiture.
- Volant, accélérateur, pédale de freins, etc.
- Tout ce qu’il faut savoir pour conduire (mais pas la réparer ni comprendre comment
ça marche).
- L’interface ne change pas, même si l’on change de moteur … et même si on change
de voiture (dans certaine mesure) : abstraction de la notion voiture (en tant qu’objet 3
à conduire)
Tout ce qui n’est pas nécessaire de connaitre à l’extérieur d’un objet devrait être dans le corps de
l’objet et identifié par le mot-clé « private : ». À l’inverse, l’interface qui est accessible de
l’extérieur, se déclare avec le mot-clé « public : ».
NB : si aucun droit n’est précisé, c’est private par défaut.
Exemple :
class Rectangle {
public : // accessible partout
double surface () const {…}
private : // accessible uniquement ici dans la classe
double hauteur ;
double largeur ;
…
};
III. LES CLASSES EN C++ :
En C++, une classe se déclare par le mot-clé class.
Exemple :
class Rectangle {
…
} ; //ne pas oublier e ;
La déclaration d’une instance d’une classe se fait de la facon similaire à la déclaration d’une
variable classique : nom_classe nom_instance ;
Exemple : Rectangle rect1 ; // déclare une instance rect1 de la classe Rectangle.
1. Déclaration des attributs :
La syntaxe de la déclaration des attributs est la même que celle des champs d’une Structure :
type nom_attribut ;
Exemple : les attributs hauteur et largeur, de type double, de la classe Rectangle pourront être
déclarés par :
Class Rectangle {
Double hauteur ;
Double largeur ;
…};
2. Accès aux attributs :
L’accès aux valeurs des attributs d’une instance de nom nom_instance se fait comme pour
accéder aux champs d’une structure : nom_instance.nom_attribut ;
Exemple : la valeur de l’attribut hauteur d’une instance rect1 de la classe Rectangle sera
référencée par l’expression : rect1.hauteur
4
3. Déclaration des méthodes :
La syntaxe de la définition des méthodes d’une classe est la syntaxe normale de définition des
fonctions :
type_retour nom_méthodes (type_arg1 nom_arg1, …) {
//corps de la méthode
…
}
Sauf qu’on n’a pas besoin de passer les attributs de la classe comme arguments aux méthodes de
cette classe.
Exemple : une méthode surface () de la classe Rectangle pourrait être définie par :
class Rectangle {
…
double surface () {
double surface ;
surface= hauteur*largeur ;
return (surface) ;
}
};
REMARQUE : à noter que ce n’est pas parce qu’on n’a pas besoin de passer les valeurs des
attributs de la classe comme arguments aux méthodes de cette classe, que les méthodes n’ont
jamais d’arguments.
Les méthodes peuvent très bien avoir des arguments : ceux qui sont nécessaires (et donc
extérieurs à l’instance) pour exécuter la méthode en question.
Exemple :
class Couleur {…} ;
class Figurecoloree {
// …
Void coloree (couleur) {…}
}
Figurecoloree une_figure ;
Couleur rouge ;
// …
une_figure.coloree (rouge) ;
//…
4. Appel des méthodes :
L’appel aux méthodes définies pour une instance de nom nom_instance se fait à l’aide
d’expressions de la forme : nom_instance.nom_methode (val_arg1, …) ;
Exemples :
void surface () const ; définie pour la classe Rectangle peut être appelée pour une instance rect1
de cette classe par : rect1.surface () ; Une_figure.coloree(rouge) ;
5
IV. AUTRES OPTIONS DE LA PROGRAMMATION ORIENTEE OBJET :
1. Actions et prédicats :
En C++ on peut distinguer les méthodes qui modifient l’état de l’objet (appelées actions) de
celles qui ne changent rien à l’objet (appelées prédicats).
On peut pour cela ajouter le mot-clé const pour les méthodes de prédicats après la liste des
arguments de la méthode :
Type_retour nom_méthode (type_arg1 nom_arg1, …) const
Exemple :
class Rectangle {
…
double surface () const {
return (hauteur*largeur) ;
}
…
};
2. Méthodes « get » (accesseurs ou prédiat ) et « set » (manipulateur ou action) :
Tous les attributs sont privés ? Et si on a besoin de les utiliser depuis l’extérieur de la
classe ?
Si le programmeur le juge utile, il inclut les méthodes publiques nécessaires…
1er : manipulateurs (méthodes set) :
o Modification
o Affectation de l’argument à une variable d’instance précise
void setHauteur (double h) {hauteur = h ;}
void setLargeur (double l) {largeur = l ;}
NB : Cette méthode a au moins un argument
2e : accesseurs (méthodes get) :
o consultation
o Retour de la valeur d’une variable d’instance précise
double getHauteur () const {return hauteur;}
double getLargeur () const {return largeur;}
3. Masquage (shadowing) :
Le masquage consiste au faite qu’un identificateur cache un autre identificateur.
Situation typique : le nom d’un paramètre cache un nom d’attribut.
Void setHauteur (double hauteur) {
Hauteur=hauteur ; // l’attribut Hauteur
avec grand H a le ment nom que
l’argument de la méthode
}
6
Si dans une méthode, un attribut est masqué alors la valeur de l’attribut peut quand même être
référencée à l’aide du mot-clé this. « This » est un pointeur sur l’instance courante.
La syntaxe pour spécifier un attribut en cas d’ambiguïté est : this->nom_attribut ;
Exemple : l’utilisation de this est obligatoire dans les situations de masquage.
Void setHauteur (double
hauteur){
This->hauteur=hauteur ;
}
4. Opérateur « :: » :
Il est possible d’écrire les définitions des méthodes à l’extérieur de la déclaration de la classe.
Ceci pour une meilleure lisibilité du code, la modularité.
Pour relier la définition d’une méthode à la classe pour laquelle est définie, il suffit d’utiliser
l’opérateur « :: » de résolution de portée.
La déclaration de la classe contient les prototypes des méthodes.
Les définitions correspondantes spécifiées à l’extérieur de la déclaration de la classe, se font sous
la forme : typeRetour Nomclasse :: nomFonction(arg1, arg2, …) {…}
EXEMPLE COMPLET DE CLASSE (1):
#include<iostream>
using namespace std;
// définition de la classe
Class Rectangle {
public :
// définition des méthodes
double surface () const {return (hauteur*largeur) ;}
double getHauteur () const {return hauteur ;}
double getLargeur () const {return largeur ;}
void setHauteur (double hauteur) {this->hauteur=hauteur ;}
void setLargeur (double largeur) {this->largeur=largeur ;}
private :
// déclaration des attributs
double hauteur ;
double largeur ;
};
// utilisation de la classe
int main() {
Rectangle rect ;
double lu ;
cout<<"Quelle hauteur ?" ; cin>>lu ;
rect.setHauteur (lu) ;
cout<<"Quelle largeur ?" ; cin>>lu ;
rect.setLargeur (lu) ;
cout<< "surface = "<<rect.surface()<<endl ;
return 0 ;
}
7
EXEMPLE COMPLET DE CLASSE (2):
La déclaration de la classe Rectangle pourrait être (dans le fichier rectangle.h).
#include<iostream>
using namespace std;
// définition de la classe
Class Rectangle {
public :
// prototypes des méthodes
double surface () const ;
double getHauteur () const ;
double getLargeur () const ;
void setHauteur (double) ;
void setLargeur (double) ;
private :
// déclaration des attributs
double hauteur_;
double largeur_;
};
Accompagné des définitions « externes » des méthodes (dans un fichier rectangle.cc)
double Rectangle :: surface () const
{
return (hauteur_*largeur_) ;
}
double Rectangle :: getHauteur () const
{return hauteur_ ;}
double Rectangle :: getLargeur () const
{return largeur_ ;}
void Rectangle :: setHauteur (double h)
{hauteur_=h;}
void Rectangle :: setLargeur (double l)
{largeur_=l ;
}
