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.
