Leçon 3 : Héritage IUP 2 Génie Informatique

Slides:



Advertisements
Présentations similaires
Erratum C Surcharge For(int x=0; … 2.
Advertisements

Spécialisation/généralisation Héritage Polymorphisme.
Spécialisation/généralisation Héritage Polymorphisme
1 Quelques précisions sur l'héritage. 2 Signification de super.f() appel à la méthode f() masquée super : désigne l'objet appelant comme s'il était de.
Langages objet Définitions Traduction des méthodes en C++
F. Voisin : Introduction à Java 1 Introduction à Java - lhéritage - Frédéric VOISIN FIIFO - « Remise à Niveau »
Tarak Chaari, Stéphane Frénot, Frédérique Laforest, Frédéric Le-Mouël JAV1 JAV – TD 5 Lhéritage en Java.
TD 1 IJA Introduction Objet, méthode, attribut Classe, instance
Programmation Orientée Objet (POO)
Introduction à la POO: Les classes vs les objets
Chapitre III Héritage (début)
FSAB1402: Informatique 2 Techniques de Programmation Orientée Objet
Programmation orientée objet
Langage Oriente Objet Cours 4.
Leçon 6 : Structures de données dynamiques IUP 2 Génie Informatique Méthode et Outils pour la Programmation Françoise Greffier.
Mémoire de fin d’études présenté par Amine Brikci-Nigassa
IFT1025, Programmation 2 Jian-Yun Nie
Introduction au paradigme objet Concepts importants surcharge (overload) redéfinition (override) Définition d’une classe Définition des attributs.
© 2007 P. Van Roy. All rights reserved. FSAB1402: Informatique 2 Le Langage Java et les Exceptions Peter Van Roy Département dIngénierie Informatique,
C++ : classes Introduction aux Langages Orientés Objets
Les Classes les structures en C (struct) regroupent des variables : structuration de l'analyse mais problèmes de cohérence problèmes de sécurité d'accès.
77 Utilisation des classes (suite). 7-2 Objectifs A la fin de ce cours, vous serez capables de : Définir des méthodes surchargées dans une classe Fournir.
Langage Oriente Objet Cours 3.
POO : Objets et classes (Rappels)
Master 1 SIGLIS Java Lecteur Stéphane Tallard Chapitre 5 – Héritage, Interfaces et Listes génériques.
Leçon 2 : Surcharge des opérateurs IUP 2 Génie Informatique Méthode et Outils pour la Programmation Françoise Greffier Université de Franche-Comté.
Structures de données IFT-2000
Structures de données IFT-10541
Introduction au paradigme orienté-objet (suite)
Design Pattern: Decorator
1 IFT 6800 Atelier en Technologies dinformation Le langage de programmation Java chapitre 3 : Classes et Objects.
Langages orientés objets
Chapitre III Héritage. POO-L3 H. Fauconnier2 Chapitre III: Héritage A) Extensions généralités Affectation et transtypage B) Méthodes Surcharge et signature.
Cours 4 Héritage (suite).
COURS DE PROGRAMMATION ORIENTEE OBJET :
Héritage Lhéritage permet de spécialiser une classe en définissant une relation de type « est une sorte de ». #include comptebancaire.h class CompteEpargne.
Leçon 1 : notion dobjet IUP Génie Informatique Besançon Méthode et Outils pour la Programmation Françoise Greffier Université de Franche-Comté.
99 Réutilisation du code grâce à l'héritage. 9-2 Objectifs À la fin de ce cours, vous serez capables de : Définir l'héritage Utiliser l'héritage pour.
INF1101 Algorithmes et structures de données
Structures de données IFT-2000 Abder Alikacem L’héritage en C++ Département d’informatique et de génie logiciel Édition Septembre 2009.
Structures de données IFT-2000 Abder Alikacem Concepts orientés objet Édition Septembre 2009 Département dinformatique et de génie logiciel Département.
Héritage Licence Informatique Besançon Méthode et Outils pour la Programmation Françoise Greffier.
Héritage et composition
Travaux Pratiques Représentation des connaissances
LIFI-Java 2004 Séance du Mercredi 22 sept. Cours 3.
La notion de type revisitée en POO
11/04/ L'héritage Cours 7 Cours 7.
Programmation objet La base.
Variables et accès en Java. Déclaration des variables final transient static private Printer hp; transient => ne doivent pas être sérialisées volatile.
12/04/ Le polymorphisme Cours 8 Cours 8.
© 2005 P. Van Roy. All rights reserved. FSAB1402: Informatique 2 Le Langage Java Peter Van Roy Département d’Ingénierie Informatique, UCL
Tutorat en bio-informatique
5ième Classe (Mercredi, 19 octobre) Prog CSI2572.
Tutorat en bio-informatique Le 14 novembre Au programme… Les objets –Propriétés (attributs) –Constructeurs –Méthodes.
C++ L’HERITAGE Fayçal BRAÏKI DUT INFORMATIQUE.
PHP objet Jérôme CUTRONA 10:13:27 Programmation Web
Les classes présenté par: RAHMOUNE RIME / ZEKRI SELMA.
Cours du 5 novembre.
Les classes Introduction aux Langages Orientés Objets
La programmation par objets Principes et concepts Etude de Smalltalk.
Cours 4 (14 octobre) Héritage. Chapitre III Héritage.
Introduction à la programmation objet avec java
Héritage Conception par Objet et programmation Java
Introduction à la Programmation Orientée Objet
Master 1 SIGLIS Jave Lecteur Stéphane Tallard Chapitre 5 – Correction TD.
Retour sur les interfaces Les méthodes définies dans une interface sont des méthodes qui doivent absolument être implémentées par une ou des sous-classes.
Transcription de la présentation:

Leçon 3 : Héritage IUP 2 Génie Informatique Méthode et Outils pour la Programmation Françoise Greffier

LES FORMES GEOMETRIQUES Où l’on propose une application permettant de : Dessiner un carré, un rectangle, un cercle, un triangle …. Associer au dessin : périmètre et surface.

CLASSE FORME enum categorie { carre, rectangle, cercle, triangle}; class figure {public: . . . void dessiner (void); double périmètre (void); double surface (void); private : categorie c; double a,b; point centre; };

IMPLANTATION double figure::surface(void) {switch c { case carre : return (a*a); case rectangle : return (a*b); . . . }

POURQUOI HERITER ? Relier des objets entre eux (famille) Factoriser des traitements (Réutilisabilité) Représenter le centre de la figure (généralisation) IDENTIFICATION DES OBJETS Un cercle (rayon) ne « ressemble » pas à un rectangle (diagonale) Faciliter l ’extension l’application (Extensibilité) On traite les ellipses

COMMENT HERITER ? HIERARCHIE DE CLASSES GESTION D’UNE Factorisation Toute figure géométrique a un centre Spécialisation (un objet est un cas particulier d ’un autre objet) Un carré est un cas particulier de rectangle Enrichissement (un objet a des propriétés propres) Un triangle rectangle comprend le calcul de l’hypoténuse

GRAPHE D’HERITAGE Figure Polygone Ellipse Hérite de Figure Polygone Ellipse Parallélogramme triangle Cercle Rectangle triangle rectangle

RELATION D’HERITAGE M Classe mère D Classe dérivée Héritage simple : La classe D hérite de la classe M Héritage simple : Un unique ascendant direct

Relation : « est une sorte de » HERITAGE PUBLIC Héritage public Relation : « est une sorte de » Les classes dérivées héritent de la classe mère en se spécialisant Les membres public de la classe mère deviennent des membres public des classes dérivées. Les classes dérivées peuvent avoir des membres supplémentaires. (enrichissement)

HERITAGE public en C++ public M class D: {public : Méthodes redéfinies : void f(void); Méthodes supplémentaires : void h(void); private: Caractéristiques supplémentaires }; public M class M {public : void f(void); void g(void); private: ... }; L ’instance W de la classe D a accès à la section public des classes D et M

Partage des caractéristiques class D: {public : ... private: Caractéristiques supplémentaires }; public M class M {public : ... protected : private: }; Pour la classe D : les membres de la section protected de la classe mère M sont accessibles par ses fonctions membres et fonctions amies Pour la classe M : les membres de la section protected se comportent comme s’ils étaient placés dans sa section private.

HERITAGE : public Partage des caractéristiques public M class D : {public : protected: private : }; class M {public : protected: private : }; Partie inaccessible héritée

Accès aux caractéristiques class D: {public : ... private: Caractéristiques supplémentaires }; public M class M {public : ... protected : private: }; accès aux sections public et protected de la classe M Classe D (ex: fonction main) accès aux sections public des classes M et D Vision utilisateur

Accès aux caractéristiques class D: {public : ... private: Caractéristiques supplémentaires }; public M class M {public : ... protected : private: }; Attention : l ’utilisation du qualificateur protected est contraire au principe d ’encapsulation. Si des modifications sont apportées à la section protected de la classe M alors toutes les classes dérivées qui utilisent l ’accès direct à cette section sont susceptibles de subir des modifications.

Les constructeurs class rectangle : public figure class figure rectangle(double,double,point); // constructeur par initialisation : //longueur et largeur, centre }; public figure class figure {public : figure (point); //construct :centre private : point centre; }; rectangle::rectangle(double a,double b,point c):figure (c) { lo=a; la=b; } Appel du constructeur de la classe mère

Les constructeurs Lors de la création d ’une instance d ’une classe dérivée son constructeur et tous les constructeurs de ses classes parentes sont activés. Héritage simple : Les constructeurs sont activés de la racine de l ’arbre d ’héritage vers les classes dérivées Activation : d ’un constructeur par défaut (qui doit exister) ou bien appel à un constructeur explicite.

Les destructeurs Lors de la destruction d’une instance d ’une classe dérivée son destructeur et tous les destructeurs de ses classes parentes sont activés. Héritage simple : Les destructeurs sont activés de la classe dérivée vers la racine de l ’arbre d ’héritage.

Fonctions polymorphes class D1: {public : void f(void); void h(void); private: Caractéristiques supplémentaires }; class D2 : {public : void f(void); void k(void); private: Caractéristiques supplémentaires }; class M {public : void f(void); void g(void); private : . . . Protected : }; public M public M Le polymorphisme offre la possibilité d ’associer à une méthode un code différent selon l’objet auquel elle appartient. Exemples : f ou tracer pour les formes géométriques

Fonctions polymorphes (Liaison statique) class D1: {public : void f(void); void h(void); ...}; public M class D2 : {public : void f(void); void k(void); …}; public M class M {public : void f(void); void g(void); private : . . . Protected : }; Comment dans une hiérarchie par héritage, le compilateur sélectionne la méthode polymorphe à exécuter parmi les surcharges incluses dans la hiérarchie de classes ? D1 w1; D2 w2; w1.f( ); w2.g( ); Vision utilisateur Liaison statique

Fonctions polymorphes (surcharge ) Liaison statique D1 w1; D2 w2; w1.f( ); w2.g( ); Vision utilisateur Classe M Classe D1 D2 Le type de W1 est D1, par conséquent le compilateur regarde si la méthode f est dans la classe D1 Si oui, celle-ci est exécutée Si non, il la recherche dans la première classe ascendante, etc... Résolution de la surcharge par liaison statique

Héritage et COMPATIBILITE de type class M { . . . }; class D : Vision utilisateur M* ptrM; D d; ptrM=&d; D* ptrD; M m; ptrD=&m; public M Par définition le type statique d’une expression est celui donné à la compilation. Le type dynamique d’une expression est déterminée par la valeur courante de l’expression, il peut changer en cours d’exécution. On dit que le type statique de *ptrM est M. On dit que le type dynamique de *ptrM est D. L’objet pointé par ptrM reste de type D.

Collection d’objets de types différents { figure* T[4]; // tableau de pointeurs // sur figure T[0]=new carré(); T[1]=new rectangle(); T[2]=new cercle(); T[3]=new triangle(); } Sur cet exemple, les composants du tableau T ont un type statique = figure un type dynamique = carré ou rectangle ...

Liaison statique des fonctions Vision utilisateur class figure { public : void tracer (void) { } //action vide }; class rectangle: void tracer (void); //rectangle IC est tracé figure* Ptr; Ptr = new rectangle(); Ptr -> tracer( ); Le type statique de *Ptr est figure. Par conséquent, l’instruction Ptr->tracer( ) active la méthode tracer de la classe figure. => public figure Il aurait fallu que la fonction appelée soit celle correspondant à l’objet pointé. Ce type étant dynamique : il ne faut pas que la fonction soit déterminée à la compilation. => Détermination dynamique à l’exécution  fonctions virtuelles Action vide

Liaison dynamique des fonctions Fonctions virtuelles Vision utilisateur class figure { public : void tracer (void) { } //action vide }; class rectangle : public figure void tracer (void); // instance courante est tracée figure* Ptr; Ptr = new rectangle( ); Ptr -> tracer( ); virtual La fonction tracer est virtuelle. Par conséquent, l’instruction Ptr->tracer( ); active la méthode associée au type dynamique de *ptr. => L’implémentation des fonctions virtuelles s’appuie sur une indirection virtual Tracé du rectangle

Les fonctions virtuelles Lors de la redéfinition d’une fonction virtuelle: Les fonctions virtuelles doivent avoir la même liste de paramètres. Les types de retour sont égaux ou sont des pointeurs compatibles. L’exécution des fonctions virtuelles s’appuie sur une indirection (table de pointeurs de fonctions virtuelles).

Les fonctions virtuelles Classes dérivées : Tout comme une fonction ordinaire une fonction virtuelle sert de fonction par défaut dans les classes dérivées. Une fonction virtuelle redéfinie dans une classe dérivée reste virtuelle dans la classe dérivée même si cela n’est pas spécifié.

Classe abstraite Une classe abstraite est une classe qui ne peut pas être instanciée exemple : L’instantiation de la classe figure n’a pas de sens. On ne peut pas tracer une figure, on tracera un carré, un cercle … => la méthode tracer est virtuelle pure Une classe qui comprend une fonction virtuelle pure et qui ne l’implémente pas est une classe abstraite. class figure { public : void tracer (void) ; }; virtual =0 //fonction virtuelle pure

Classe abstraite SYNTAXE : on indique qu’une méthode virtuelle est pure en ajoutant =0 en fin de spécification. class figure { public : void tracer (void) ; }; Une classe qui comprend une fonction virtuelle pure et qui ne l’implémente pas est une classe abstraite. virtual =0 //fonction virtuelle pure

UTILISATION D’UNE CLASSE ABSTRAITE Vision utilisateur class figure { public : virtual void tracer (void) =0; //fonction virtuelle pure }; figure F; figure* Ptr; Ptr = new figure; //illégal // légal //illégal L’instantiation de la classe figure n’a pas de sens. On en peut déclarer que des pointeurs sur figure. D ’une façon générale : L’instantiation d ’une classe abstraite n’a pas de sens. Elle est refusée à la compilation On en peut déclarer que des pointeurs sur une classe abstraite.