L’héritage C#

1. Concept de l'héritage 

Le concept de l’héritage est l’un des trois principaux fondements de la programmation orientée objet, le premier étant l’encapsulation, est le dernier est le polymorphisme qui sera abordé plus tard dans ce document.

L’héritage consiste à la créer une nouvelle classe dite classe drivée ou classe fille à partir d’une classe existante dite classe de base ou classe parente ou classe mère.

L’héritage permet de :

• Récupérer le comportement standard d’une classe objet (classe parente) à partir de propriétés et de méthodes définies dans celle-ci.
• Ajouter des fonctionnalités supplémentaires en créant de nouvelles propriétés et méthodes dans la classe dérivée.
• Modifier le comportement standard d’une classe d’objet (classe parente), en surchargeant certaines méthodes de la classe parente dans la classe dérivée.

 La classe de base :

class ClassA {
//propriété de la classe
public int DataA ;
//Méthode de la classe
public int FonctionA1(){
//code de la fonction fonctionA1
}
public virtual int FonctionA2() //surchargeable
{
//code de la méthode fonctionA2
}
}

 classe fille :

class ClassB : ClassA{
//propriétés de la classe ClassB
public int DataB ;
//Méthodes de la classe ClassB
public override int FonctionA2(){
//code de la méthode FonctionA2
}
public int FonctionB1(){
//code de la méthode FonctionB1
}
}

Dans cet exemple :

• ClasseA est la classe parente (classe mère).
• ClasseB est une classe dérivée (classe fille) de la classe ClasseA.
• dataA est une propriété de la classe ClasseA. Par héritage dataA est aussi une propriété de la classe ClasseB.
• dataB est une propriété de la classe ClasseB (mais pas de la classe ClasseA)
• FonctionA1 est une méthode de la classe ClasseA. Par héritage FonctionA1 est aussi une méthode de la classe ClasseB .
• FonctionB1 est une méthode de la classe ClasseB (mais de la classe ClasseA).
• FonctionA2 est une méthode des classes ClasseA et ClasseB.
  • Dans la classe ClasseA, FonctionA2() est déclarée virtual car elle est surchargeable dans la classe ClasseB
  • Dans la classe ClasseB, FonctionA2() est déclarée override car elle remplace la méthode de la classe ClasseA.

En plus des mots clés publics et private décrits dans les chapitres précédents, il est possible d’utiliser un niveau de protection intermédiaire de propriétés et de méthodes par le mot clé protected. Les exemples ci- dessous permettent d’illustrer les différents niveaux de protection.

public class ClasseA {
//Propriétés de la classe ClasseA
private int dataA1 ; protected int dataA2; public int dataA3 ;
//Méthodes de la classe ClasseA
public int FonctionA(){ DataA1=3 ;
DataA2=5 ;
DataA3=8 ;
DataB=9 ;//Faux propriété de la classe fille est inaccessible dans la classe mére.
}
}

public class ClasseB : ClasseA{
//propriété de la classe ClasseB
public int DataB ;
//méthodes de la classe ClasseB
public int FonctionB(){
DataA1=6 ;//faux ,propriété private de la classe ClasseA inaccessible. DataA2=7 ;//OK, propriété protected de la classe mére
DataA3=10 ;//OK, propriété public de la classe mére DataB=90 ;//OK, propriété de la classe B
}
}

Dans cet exemple :

• DataA1, DataA2 et DataA3 sont des propriétés de la classe ClasseA respectivement private, protected et public.
• FonctionA est une méthode de ClasseA, et FonctionB est une méthode de ClasseB.
• DatA1, DataA2 et DataA3 sont des propriétés de ClasseA. Elles sont donc directement accessibles dans toutes les méthodes ClasseA, donc dans FonctionA.
• DataB est propriété de ClasseB (classe dérivée de ClasseA). Une propriété d’une classe dérivée est inaccessible dans la classe de base.
• DataA1 est déclarée private dans la classe ClasseA. Elle est accessible uniquement pour toutes les fonctions de la classe ClasseA.
• DataA2 est déclarée protected dans la classe ClasseA. Elle est accessible uniquement pour toutes les fonctions des classes ClasseA et ClasseB.
• DataA3 est déclarée public dans la classe ClasseA. Elle est donc directement accessible dans toutes les instances.

Lors des affectations (opérateur =), il est possible de mélanger des instances de classes différentes. Cependant, il y a quelques règles à observer :

ClasseA ObjA ; ClasseB ObjB ;

• ClasseA est une classe de base.
• ClasseB est une classe dérivée de ClasseA.
• ObjA est une instance de la classe ClasseA.
• ObjB est une instance de la classe ClasseB.
• L’instruction ObjA = ObjB ; est légale. Elle affecte à ObjA l’objet référencé par ObjB. Ceci est possible car une instance de ClasseB est aussi une instance de ClasseA. Une variable de classe de base est compatible avec les variables de toutes ses classes dérivées.
• L’instruction ObjB = ObjA ; génère une erreur de compilation. 

Chaque constructeur d'une classe dérivée doit obligatoirement appeler le constructeur équivalent de la classe de base. Cela se fait de la façon suivante en utilisant le mot-clé base :

public class ClasseA {
//Propriétés de la classe ClasseA
private int dataA1 ; protected string dataA2; public double dataA3 ;
// Constructeur par défaut
public ClasseA (){
}
// Constructeur avec arguments
public ClasseA (int d1, string d2, double d3 ){ this.dataA1=d1;
this.dataA2=d2; this.dataA3=d3;
}
//Méthodes de la classe ClasseA
...
}

public class ClasseB : ClasseA {
//propriété de la classe ClasseB
public int DataB ;
// Constructeur par défaut
public ClasseB () : base(){
}
// Constructeur avec arguments
public ClasseB (int d1, string d2, double d3, int d4 ) : base(d1,d2,d3)
{
this.DataB=d4;
}
//Méthodes de la classe ClasseB
...
}