POO :

Programmation Orientée Objet

Présentation
 MOUMMADI Kamal
 Développement informatique :

WEB-Mobile.
 Email : kamal.moummadi@gmail.com

www.devsasmaroc.com
Concept d’objet
 Qu’est-ce qu’un objet ?
 Le monde qui nous entoure est composé
d'objets
 Ces objets ont tous deux caractéristiques
 un état
 un comportement
Concept d’objet
 Exemples d’objets du monde réel
 chien
 état : nom, couleur, race, poids....
 comportement : manger,aboyer,renifler...
 Bicyclette
 état : nombre de vitesses, vitesse courante,
couleur
 comportement : tourner, accélérer, changer de
vitesse
L’approche objet
 L’approche objet :
 Programmation dirigé par les données et non par les
traitements
 les procédures existent toujours mais on se concentre d’abord

sur les entités que l’on va manipuler avant de se concentrer sur

la façon dont on va les manipuler
 Notion d’encapsulation
 les données et les procédures qui les manipulent (on parle de

méthodes) sont regroupés dans une même entité (la classe).

 Un objet informatique
 maintient son état dans des variables (appelées champs)
 implémente son comportement à l'aide de méthodes
objet informatique = regroupement logiciel de variables et de méthodes
L’approche objet
 Cycle de vie
 construction (en mémoire)
 Utilisation (changements d’état par affectations, comportements
par exécution de méthodes)
 destruction
Concept de classe
 La « classification » d’un univers qu’on cherche à modéliser est
sa distribution systématique en diverses catégories, d’après des
critères précis
 En informatique, la classe est un modèle décrivant les
caractéristiques communes et le comportement d’un ensemble
d’objets : la classe est un moule et l’objet est ce qui est moulé à
partir de cette classe
 Mais l'état de chaque objet est indépendant des autres
 Les objets sont des représentations dynamiques (appelées
instances) du modèle défini au travers de la classe
 Une classe permet d’instancier plusieurs objets
 Chaque objet est instance d’une seule classe
La classe (1) : définition
 Classe : description d’une famille d’objets ayant une même
structure et un même comportement. Elle est caractérisée par :

 Un nom
 Une composante statique : des champs (ou attributs) nommés
ayant une valeur. Ils caractérisent l’état des objets pendant
l’exécution du programme
 Une composante dynamique : des méthodes représentant le
comportement des objets de cette classe. Elles manipulent les
champs des objets et caractérisent les actions pouvant être
effectuées par les objets.
La classe (2) : représentation
graphique
Nom

Champs

Méthodes
Intérêt de la POO
 Le code est plus sûr

 Les programmes sont plus clairs

 La maintenance des applications est facilitée

 Le code est facilement réutilisable

 Il est facile de créer de nouveaux algorithmes

légèrement différents par clonage d’un algorithme
existant

 Il est facile de faire évoluer des programmes

Langages Objets
 C++
 Java
 Smalltalk
 Eiffel
les caractéristiques de l’Objet
La 1ère étape consiste à déterminer
 les entités que l'on souhaite manipuler

 la description générique qui relie toutes

ses entités.
Exemple
 Prenons ces informations :
 11 janvier 1944 (Manifeste de l'Indépendance)
 06 Novembre 1975 (Marche Verte)
 05 Mai 2016 (Cours POO)
 Ce sont des dates.
 Chaque date se caractérise par :
 un jour
 un mois
 une année.
Les Dates
Date Indépendance
• Jour • 11

• Mois • Janvier

• Année • 1944

Cours POO Marche Verte

•5 • 06

• Mai • Novembre

• 2016 • 1975
Classes
 Le Jour, le Mois et l’Année sont les
attributs d’une Date.

 Cet ensemble d’attributs est appelé une

Classe.
Objets
 Le 11 Janvier 1944 et le 06 Novembre
1975 sont chacune des instances de la
classe Date.

 Chacune de ces dates est appelée un

Objet.
Autre Exemple : Les planètes
 Saturne : planète gazeuse. Son diamètre est de 120.536
km. Elle est à une distance moyenne de 1.426.725.400 km
du Soleil.
 Mars : planète rocheuse. Son diamètre est de 6794 km.
Elle est à une distance moyenne de 227.936.640 km du
Soleil.
 Jupiter : planète gazeuse. Son diamètre est de 142.984
km. Elle est à une distance moyenne de 779 millions de
km du Soleil.
 Terre : planète rocheuse. Son diamètre est de 12.756,28
km. Elle est à une distance moyenne de 150.000.000 km
du Soleil.
Planète (suite)
Ces planètes ont en commun :
 Le Type : Rocheuse, Gazeuse

 La Distance au Soleil : 227936640, 779

millions, 1426725400, 150000000
 Le Diamètre : 12756.28, 120536,
142984, 6794
 La classe Planete
Planete Terre Saturne
•Type • Rocheuse • Gazeuse
•DistanceAuSoleil • 150000000 • 1426725400
•Diametre • 12756,28 • 120536

Jupiter Mars
• Gazeuse • Rocheuse
• 779 millions • 227936640
• 142984 • 6794
Encore un Exemple
 Mohamed, 22 ans, étudiant en IVE.
groupe 1, sous-groupe 2.
 Asma, étudiante en INFO, a 21 ans.
Elle est dans le sous-groupe 1 du
Groupe 2.
 Rachid, un garçon de 21 ans, est en
IHE. Il est dans le groupe 3, sous-
groupe 2.
Etudiant
Ici, un étudiant se caractérise par
 age

 département

 groupe

 sous-groupe

 sexe
 Etudiant – 1ère possibilité
Mohamed Asma
Etudiant • 22 • 21
• Age
• IVE • INFO
• Departement
•1 •2
• Groupe Rachid
•2 •1
• SousGroupe • 21
• Garçon • Fille
• Sexe • IHE
•3
•2
• Garçon
 Etudiant – 2ème possibilité
Etudiant1 Etudiant3
Etudiant • Mohamed • Asma
• Prénom
• 19 • 21
• Age
• IVE • INFO
• Departement Etudiant2
•1 •2
• Groupe • Rachid
•2 •1
• SousGroupe • 21
• Garçon • Fille
• Sexe • IHE
•3
•2
• Garçon
Définir une classe en C++
class CDate class NomClasse
{ {
typeAttribut1 nomAttribut1;
int Jour;
typeAttribut2 nomAttribut2;
int Mois; typeAttribut3 nomAttribut3;
int Annee; typeAttribut4 nomAttribut4;
}; …
};
Objet en C++
Comment créer un objet independance de
type CDate ?
 La classe CDate est un type comme un
autre (int, char…)
{
CDate independance;
}
independance
Initialiser un Objet
Pour l’instant, notre objet independance
n’est pas encore le 11 Janvier 1944.

 Spécifier chaque attribut à la main

{
independance.Jour = 11;
independance.Mois = 01;
independance.Annee = 1944;
}
Initialiser un Objet
Autre exemple : la date marcheverte
que l'on souhaite initialiser au 06
Novembre 1975
{
CDate marcheverte;
marcheverte.Jour=06;
marcheverte.Mois=11;
marcheverte.Annee=1975;
}
Intérêt de la POO
Spécifier des comportements génériques
communs à tous les objets de notre
classe.

Par exemple :
 s'initialiser

 s'afficher

 vérifier si c'est contemporain

Initialiser
class CDate void InitDate(int jour,
{ int mois,
int Jour ; int annee)
int Mois ; {
int Annee ; Jour = jour;
Mois = mois;
Annee = annee;
}
};
Afficher
class CDate void Affiche()
{ int Jour ; {
int Mois ; cout
int Annee ; << Jour << "/"
<< Mois <<
"/" <<Annee ;
void InitDate(int jour,
}
int mois,
int annee) };
{…}
Contemporain
class CDate bool Contemporain()
{ int Jour; {
int Mois;
if( Annee >= 2000 )
int Annee; return true;
return false;
void InitDate(int jour,
}
int mois,
int annee) };
{…}

void Affiche()
{…}
Exemple
{
CDate independance;
independance.InitDate(11,01,1944);
CDate marcheverte;
marcheverte.InitDate(06,11,1975);

cout <<"La date "; independance.Affiche();

cout <<" est elle contemporaine ? "
<< independance.Contemporaine()<<endl;

cout <<"La date "; marcheverte.Affiche();

cout <<" est elle contemporaine ? "
<< marcheverte.Contemporaine()<<endl;
}
 Résultat
{
CDate independance;
CDate marcheverte;

independance.InitDate(11,01,1944);
La date 11/01/1944 est elle contemporaine ? no
cout <<"La date ";
independance.Affiche();
cout <<" est elle contemporaine ? "
<<
independance.Contemporaine()<<endl;

marcheverte.InitDate(06,11,1975);
cout <<"La date "; La date 06/11/1975 est elle contemporaine ? no
marcheverte.Affiche();
cout <<" est elle contemporaine ? "
<<
marcheverte.Contemporaine()<<endl;
}
Initialiser un Objet – 2ème
Il existe une autre méthode pour initialiser les
attributs d'un objet :
 utiliser les constructeurs.
Un constructeur est une "procédure" appelée
automatiquement qui permet de spécifier
chacun des attributs de l’objet en fonction de
ses paramètres.
Un constructeur ne possède aucun type de
retour, même pas void.
Constructeur par défaut
class CDate
{
int Jour ;
int Mois ;
int Annee ;
CDate()
{/* constructeur par défaut qui initialise
l'objet date au 05 Mai 2016 */
Jour = 5; Mois = 5; Annee = 2016;
}
};
Créer mon objet
{
CDate uneDate;

cout << "La date ";

uneDate.Affiche();
cout<< " est elle contemporaine ? "
<< uneDate.Contemporaine();
}
 Créer mon objet (suite)
Le programme va appeler automatiquement le
{ constructeur (aucun paramètre).
CDate uneDate;
L'objet uneDate sera donc initialisé avec
le 05 Mai 2016

cout << "La date ";

uneDate.Affiche();
cout << " est elle contemporaine ? "
<< uneDate.Contemporaine();
il appelle ensuite la fonction Affiche() pour afficher
la date puis la fonction Contemporaine() pour
savoir si elle est contemporaine de notre
siècle.
On obtient :

} La date 05/05/2016 est elle contemporaine ? yes

Autres Constructeurs Possibles
CDate (int jour, int mois, int annee)
{
Jour = jour;
Mois = mois;
Annee = annee;
}

CDate (int jour, int mois)

{
Jour = jour;
Mois = mois;
Annee = 2016;
}
Usage
{
CDate uneDate;
CDate independance (11,01,1944);
CDate dateCetteAnnee(5,5);
uneDate.Affiche(); // 05/05/2016
independance.Affiche(); // 11/01/1944
dateCetteAnnee.Affiche(); // 05/05/2016
}
Écriture d'un Constructeur
class MaClass
{
type1 Attribut1;
…
MaClass(typeP1 parametre1, typeP2 parametre2, …)
{
…
}
};
Sécurité
Comment empêcher un programmeur de
définir la date 38/14/-362 ?
{
CDate dateImpossible;
dateImpossible.Jour=38;
dateImpossible.Mois=14;
dateImpossible.Annee=-362;
dateImpossible.Affiche();
}
mots clés
Le C++ met à votre disposition 3 mots
clés :
 public:

 private:

 protected:
public:
 Tous les attributs ou fonctions situés
sous le mot clé public: sont accessibles
en dehors de l’objet ou depuis
n'importe quelles fonctions de la classe.

Remarque : Les fonctions précédentes

ne fonctionnent qu'en ajoutant le mot
clé public:
Exemple de public:
class CDate {
{
CDate uneDate;
public:
int Jour;
int Mois; uneDate.Jour=06;
int Annee; uneDate.Mois=10;
uneDate.Annee=1912;
void Affiche()
{
cout uneDate.Affiche(); // 06/10/1289
<< Jour << "/" }
<< Mois << "/"
<< Annee;
}
};
private:
 Tous les attributs ou fonctions situés
sous le mot clé private: ne sont
accessibles que depuis les fonctions de
l’objet.
 C'est le comportement par défaut si
aucun mot clé n'est spécifié.
private:
class MaClasse {
{ MaClasse objet;
public:
int NbreAccessible;
private:
objet.NbreAccessible=3; // OK
int NbreProtege;
objet.NbreProtege=7; // Impossible
void Affiche() {
cout<<NbreProtege<<end; objet.Affiche(); // Impossible
}
public:
objet.LanceAffiche(); // OK
void LanceAffiche() {
Affiche(); }
}
};
protected:
 Utile en ce qui concerne l'héritage.
Nous verrons cela plus tard.
 Pour l'instant, protected: est équivalent
à private:
Sécurité
Problème : Comment empêcher l'accès à
certains attributs tout en donnant la
possibilité de les modifier/consulter ?

 Solution : Définir des accesseurs

Accesseur en lecture
Un accesseur en lecture est une fonction
de la classe permettant de récupérer
le contenu d'un de ses attributs.

int GetMois()
{
return Mois;
}
Accesseur en écriture
Un accesseur en écriture est une
procédure de la classe permettant de
modifier le contenu d'un de ses
attributs.
void SetMois(int mois)
{
Mois = mois;
}
Protéger les attributs de la
classe CDate
class CDate void SetMois(int mois)
{ {
private: if( mois < 1 || mois >= 12 )
int Jour; mois=1;
int Mois; Mois=mois;
int Année; }
public:
int GetMois() int GetJour(){ … }
{ void SetJour(int jour ) { … }
return Mois;
} int GetAnnee() { … }
void SetAnnee(int annee){ … }
};
Reprenons notre exemple
Essayons de définir la date 38/14/-362 ?

{
CDate dateImpossible;
dateImpossible.SetJour(38); // Jour = 1
dateImpossible.SetMois(14); // Mois = 1
dateImpossible.SetAnnee(-362); // Annee = 2016
dateImpossible.Affiche(); // 01/01/2016
}