19/03/20 1

POO

par

Jenny Benois-Pineau

Chapitre 1 Principes Généraux

19/03/20 2

Introduction

n  Pourquoi POO ? n  Crise du logiciel n  Robustesse, interchangeabilité des

composantes, réutilisation du code, extensibilité, protection

n  Langages : Java, Smalltalk, Eiffel, C++(Bjarne Stroustrup ), Python(Guido van Rossum)

n  Objectif de ce cours : appréhender les concepts objet à travers les langages C++ (essentiellement) et Java (exemples)

3

POO vs PP/PI(I)

n  Objet =<ensemble des données avec les opérations associées>

n  PP : type abstrait=<données et traitements> n  PO : Objet =<données et traitements

encapsulés>

n  Exemple : modéliser une personne

4

POO vs PP/PI(II)

n  Spécification

Type abstrait Données - nom personne - la société Opérations -Se présenter= <afficher les informations>

Objet … Le nom de la personne ne peut pas être modifié; Restreindre l’accès au champ « société »

5

POO vs PP/PI(III)

n  La mise en œuvre C++ procédural Personne.hpp

struct Personne {

char Nom[25]; char Societe[32];

}; void SePresente(Personne P);

Personne.cpp #include <iostream.h> #include <string.h> #include "personne.hpp" void SePresente(Personne P) { cout<<"Je m'apelle "<<P.Nom<<endl; cout<<"Je travaille à "<<P.Societe<<endl; } int main() {

Personne Ind; strcpy(Ind.Nom, "Toto"); strcpy(Ind.Societe, "ABC SARL"); SePresente(Ind); return 0;

}

6

POO vs PP/PI(IV)

n  Les inconvénients n  Séparation des données des traitements n  Contrôles difficiles : … Personne Ind;

SePresente(Ind); - le résultat??? n  Accès libre à toutes les composantes->possibilité

de modifier malencontreusement

7

POO : encapsulation

n  Objet P rassemble dans une même entité – encapsule- les données et les comportements

n  Un objet contrôle ses comportements : P.SePresente() vs SePresente(P)

n  On envoie un « message » à objet pour déclencher un traitement P.SePresente()

n  L’objet vérifie que le message correspond à un des comportements qu’il encapsule

n  (vérification au moment de la compilation)

n  Comment déclarer un objet?

8

Classe : un moule pour les objets

Personne

+ Nom

+ Societe

+ SePresente

Classe

Objets

P

R

Q

Instancier

9

Classe C++ Personne.hpp class Personne { public: char Nom[25]; char Societe[25]; void SePresente(); }; Personne.cpp #include ``Personne.hpp`` void Personne::SePresente(){ cout<<« Je m'appelle" <<Nom<<endl; cout<<"Je travaille à"<<Societe<<endl; }

utilisePersonne.cpp #include <iostream> #include <string.h> #include "personne.hpp« using namespace std; int main() { Personne Ind; strcpy(Ind.Nom, "Toto"); strcpy(Ind.Societe, "ABC SARL"); Ind.SePresente(); return 0; }

Fonction-membre Fonction externe – utilise les objets

19/03/20 10

Discipline de programmation

n  Une classe = n  (1) fichier .hpp n  (2) fichier .cpp n  Le pourquoi : n  (1)Séparation de la déclaration et

d’implémentation n  (2)Compilation séparée

19/03/20 11

Directives de pré-compilateur

n  Lorsque on parle de compilation du programme on sous-entend traitement du code source par

n  -pré-compilateur n  -compilateur proprement dit du fichier –

résultant de la précompilation n  -fonctions du pré-compilateur : inclusion des

fichiers, définitions des constantes et des macro-commandes, inclusion conditionnelle, pilotage des messages d’erreur.

19/03/20 12

DIRECTIVE « include »

n  Fichier MaClasse.cpp n  #include <iostream> n  #include “MaClasse.hpp ” n  #include “Util.h” n  using namespace std; // utilisation de l’espace de

nommage n  int main(){

n  MaClasse C; n  … n  return 0;

n  }

19/03/20 13

Directive « define »

n  Directive « define » est utilisée pour la définition des constantes, des macro-fonctions,

n  Syntaxe : n  #define identificateur chaîne de substitution n  Ex : n  #define TailleMax 1000 n  classe Tableau{ n  int Tab[TailleMax]; n  int longueur_eff; n  };

19/03/20 14

Definition des macro-fonctions

n  #define identificateur(paramètre,…) n  Exemple : n  #define ABS(x) x<0? x:-x

n  …. n  x=-2; n  ABS(x); n  cette affectation sera substituée par n  x<0?x:-x n  Veiller à la correspondance du nombre et du type

d’arguments: n  ABS(”ABC”) ó “ ABC ”<0? ”ABC ”:- ”ABC ”

19/03/20 15

Inclusion conditionnelle(1)

n  Compilation séparée : permet de corriger les erreurs de syntaxe, des erreurs de correspondance des déclarations aux implémentations, … pour chaque classe séparément.

n  g++ -c MaClasse.cpp –compilation d’un fichier-source

n  Résultat : MaClasse.o –fichier-objet

19/03/20 16

Inclusion conditionnelle(2)

n  Dans un fichier .hpp n  #ifndef MaClasse_H n  #define MaClasse_H n  class MaClasse{

….. }; #endif

19/03/20 17

Branchement conditionnel

n  #ifdef identificateur n  Partie –alors

n  #else n  Partie-sinon

n  #endif n  Exemple : n  #ifdef VERBOSE n  cout<<“ Valeur a “ =<<a;

18

Classe Java

Personne.java import java.awt.*; class Personne { public String Nom; public String Societe public void Se Presente(){ system.out.println ("Je m'appelle" +Nom); system.out.println ("Je travaille à" +Societe); }

public static void main (String args[ ]){ Personne P; P=new Personne(); P.nom=Personne(); P. societe=``ABC``; P.SePresente(); } //toute méthode fait partie d’une classe

Personne.java import java.awt.*; class Personne { public String Nom; public String Societe public void SePresente(){ system.out.println ("Je m'appelle" +Nom); system.out.println ("Je travaille à" +Societe); } class Test{ public static void main(String args[ ]){ ….. } }

19

Fonctions –membres C++(1) Personne.hpp class Personne { public: char Nom[25]; char Societe[25]; void SePresente(); }; Personne.CPP void Personne::SePresente(){ cout<<« Je m'appelle" <<Nom<<endl; cout<<"Je travaille à"<<Societe<<endl; }

Personne.hpp class Personne { public: char Nom[25]; char Societe[25]; inline void SePresente(){ cout<<Nom; cout<<Societe; } };

Fonction inline : le code est recopié à la place de l’appel pour gagner du temps d’exécution

20

Fonctions –membres C++(2) Personne.hpp class Personne { public: char Nom[25]; char Societe[25]; void SePresente(); }; Personne.CPP void Personne::SePresente(){ cout<<« Je m'apelle" <<Nom<<endl; cout<<"Je travaille à"<<Societe<<endl; }

Personne.hpp class Personne { public: char Nom[25]; char Societe[25]; void SePresente() const{ cout<<Nom; cout<<Societe; } char* surname () const {return Nom;}; };

Fonctions constantes – laissent l’objet inchangé

19/03/20 21

Fonctions constantes(1)

n  On déclare les objets constants afin de ne pas pouvoir les changer (héritage du langage C)

n  class point { public :

n  double x; n  double y; n  void affiche(); }; const point c; c.affiche(); //erreur de compilation

19/03/20 22

Fonctions constantes(2) ….. public :

n  Double x; n  Double y; n  void affiche(); //les deux fonctions sont identiques n  void affiche () const; // mais! n  }; …. int main(){ const point c; c.affiche(); //compilation normale, c’est la méthode « const » qui est

invoquée … } Java : la notion de fonction membre constante n’existe pas

19/03/20 23

Protection des membres

Personne

- Nom

- Societe

+ SePresente

+ Public

- Private

O Protected

24

Protection des données Personne.hpp class Personne { private : char Nom[25]; char Societe[25]; public : void SePresente(); }; Personne.CPP void Personne::SePresente(){ cout<<« Je m'appelle" <<Nom<<endl; cout<<"Je travaille à"<<Societe<<endl; }

utilisePersonne.cpp #include <iostream.h> #include <string.h> #include "personne.hpp" int main() { Personne Ind; strcpy(Ind.Nom, "Toto"); Erreur de compilation strcpy(Ind.Societe, "ABC SARL"); Erreur de compilation Ind.SePresente(); return 0; }

19/03/20 25

Accessibilité

Nom_Cls

private

public

Fonctions usuelles

Classe

19/03/20 26

Masquage de l’information File.hpp class File{ private : xxxxxxxxxxx public : void enfiler(int valeur); void defiler(); int valeur_file const(); …….. };

Masquage de l’implémentation La modification de la partie privée n’affecte pas les programmes applicatifs – efficacité du processus de développement.