Vous êtes sur la page 1sur 4

Héritage

Le troisième aspect essentiel des objets est la notion d’héritage L’héritage est une technique
extrêmement efficace permettant la l’enrichissement des classes par la création de classes
plus spécifiques, appelées sous-classes, à partir de classes plus générales déjà existantes,
appelées sur-classes.

Plus précisement, lorsqu’une sous-classe est définie [à partir d’une sur-classe], elle va
hériter de l’ensemble des attributs et méthodes de sa sur-classe, c’est-à-dire que ces attributs
et méthodes seront disponibles pour les instances de la sous-classe, sans qu’il soit nécessaire
de les redéfinir explicitement
Naturellement, des attributs et/ou méthodes supplémentaires peuvent être définis par la
sous-classe, et constituent l’enrichissement apportée par cette classe.

L’héritage permet donc :


 d’expliciter des relations structurelles et sémantiques entre classes
 de réduire les redondances de description et de stockage des propriétés

Par transitivité, les instances d’une sous-classe possèdent :


 les attributs et méthodes (hors constructeurs/destructeur) de l’ensemble des classes
parentes (super-classe, super-super-classe, etc.)

Sous-classe, Super-classes:

Une super-classe :
 est une classe « parente »
 déclare les attributs/méthodes communs
 peut avoir plusieurs sous-classes

Une sous-classe est :


 une classe « enfant »
 étend une (ou plusieurs) super-classe(s)
 hérite des attributs, des méthodes et du type de la super-classe
Un attribut/une méthode hérité(e) peut s’utiliser comme si il/elle était déclaré(e)
dans la sous-classe au lieu de la super-classe (en fonction des droits d’accès,
voir plus loin)
 On évite ainsi la duplication de code
1.Héritage: syntaxe

La syntaxe permettant de définir des sous-classes est: Exemple:

class RectanglePlein :
class <nom de la classe enfant> : <nom de la classe parente> Rectangle
{ {
[public:] public:
// déclaration des attributs et méthodes Color couleur;
// spécifiques à la sous-classe // ...
... };
};

Modes d'héritage d'une classe dérivée:


Soit D une classe dérivée d'une classe C.
Le mode d'héritage de D définit le statut dans D des membres hérités de C, c'est-à-dire
si les membres hérités de C sont privés, protégés ou publics dans D
 Dans le mode d'héritage public :
 les membres public de C restent publics dans D
 les membres protégés de C restent protégés dans D
 les membres privés de C restent privés à C
 Dans le mode d'héritage protected :
 les membres publics et protégés de C sont protégés dans D
 les membres privés de C restent privés à C
 Dans le mode d'héritage private :
 Les membres publics et protégés de C sont privés dans D
 les membres privés de C restent privés à C

2.Accès aux propriétés d’une classe

Jusqu’à maintenant, l’accès aux membres (attributs et méthodes) d’une classe pouvait
être :
 soit public : visibilité totale à l’intérieur et à l’extérieur de la classe (mot-clé public)
 soit privé : visibilité uniquement à l’intérieur de la classe (mot-clé private)
Un troisième type d’accès régit l’accès aux attributs/méthodes au sein d’une
hiérarchie de classes :
 l’accès protégé : assure la visibilité des membres d’une classe dans les classes de sa
descendance Le mot clé est «protected».
Le niveau d’accès protégé correspond à une extension du niveau privé permettant
l’accès aux sous-classes... mais uniquement dans leur portée (de sous-classe), et non pas
dans la portée de la super-classe

2.Modifications de propriétés héritées

L’héritage permet non seulement d’ajouter des propriétés et d’utiliser (dans la mesure
des droits d’accès) celles définies dans les classes de l’ascendance, mais il permet également
de modifier ces attributs et méthodes
Exemple:Redéfinition de la méthode surface pour la sous-classe RectanglePlein

class Rectangle
{
public:
int hauteur;
int largeur;
// les constructeurs ...
int surface()
{
return (hauteur*largeur);
}
// le reste de la classe ...
};
class RectanglePlein: Rectangle
{
public:
int interieur;
// les constructeurs ...
int surface()
{
return abs(hauteur*largeur);
}
// le reste de la sous-classe ...
};

Lors de redéfinition d’attributs ou de méthodes, les propriétés originelles ne sont pas


réellement remplacées dans la sous-classe mais simplement masquées par les nouvelles.
De ce fait, il est toujours possible d’y faire référence, en utilisant l’opérateur de
résolution de portée « :: »
<nom de surclasse>::<méthode ou attribut>

3.Constructeurs et héritage

Lors de l’instanciation d’une sous-classe, il est non seulement nécessaire d’initialiser


les attributs propres à cette sous-classe, mais également ceux hérités des sur-classes.

Il n’est pas raisonnable d’obliger le concepteur de la sous-classe à réaliser lui-même


l’initialisation des attributs hérités, car en particulier, il est fort possible que l’accès à ces
attributs soit purement et simplement interdit. La solution pour cela est d’invoquer les
constructeurs de ces classes. L’invocation [explicite] du constructeur de la sur-classe se fait
au début de la section d’initialisation des constructeurs de la sous-classe, et sa syntaxe est
identique à celle de l’invocation d’une méthode quelconque:
classe SousClasse : public SurClasse
{
SousClasse(<liste de paramètres>)
: SurClasse(<arguments>),
<attribut1>(<valeur1>),
...
<attributn>(<valeurn>)
{
// corps du constructeur} ... };
Si la classe parente n’admet pas de constructeur par défaut, l’invocation explicite d’un autre
de ses constructeurs est obligatoire, dans les constructeurs de la sous-classe.
➱ La sous-classe doit obligatoirement admettre (au moins) un constructeur explicite:

class Rectangle class RectanglePlein: public Rectangle


{ {
public: public:
int hauteur; int couleur;
int largeur; RectanglePlein(int i, int h, int l)
Rectangle(int h, int l) : Rectangle(h,l),
: hauteur(h), couleur(i)
largeur(l) {}
{} // le reste de la sous-classe ...
// le reste de la classe ... };
};

Dans cet exemple, le programmeur est contraint de définir au moins un constructeur


pour RectanglePlein, afin d’indiquer au compilateur comment invoquer le constructeur de
Rectangle. Remarquons que les listes de paramètres des deux constructeurs sont totalement
indépendantes.