C# Héritage

L'héritage est l'un des concepts les plus importants de la programmation orientée objet. L'héritage nous permet de définir une autre classe à partir d'une classe, ce qui facilite la création et la maintenance des applications. Il facilite également la réutilisation du code et permet de gagner du temps de développement.

Lors de la création d'une classe, le programmeur n'a pas besoin de réécrire complètement de nouveaux membres de données et fonctions membres ; il doit seulement concevoir une nouvelle classe qui hérite des membres d'une classe existante. Cette classe existante est appelée laclasse de base, cette nouvelle classe est appeléeclasse dérivée。

Le concept d'héritage met en œuvre la relationIs-a (IS-A). Par exemple, les mammifèresIs-a (IS-A)Animal, ChienIs-a (IS-A)mammifères, donc les chiensIs-a (IS-A)Animal.

Classes de base et classes dérivées

Une classe peut hériter d'une autre classe, appelée classe de base (classe parente) et classe dérivée (classe enfant).

C# ne prend pas en charge l'héritage multiple de classes, mais il prend en charge l'héritage multiple d'interfaces ; une classe peut implémenter plusieurs interfaces.

En résumé :Une classe peut hériter de plusieurs interfaces, mais ne peut hériter que d'une seule classe.

La syntaxe de création d'une classe dérivée en C# est la suivante :

<Modificateurs d'accès> class <classe de base>
{
 ...
}
class <classe dérivée> : <classe de base>
{
 ...
}

Une classe dérivée hérite des membres de la classe de base (champs, méthodes, propriétés, etc.), sauf s'ils sont explicitement marqués comme privés.

Une classe dérivée peut appeler les constructeurs et les méthodes de la classe de base via le mot-clé `base`.

Exemple

class BaseClass
{
    public void SomeMethod()
    {
        // Implémentation de la méthode
    }
}

class DerivedClass : BaseClass
{
    public void AnotherMethod()
    {
        // Accès à la méthode de la classe de base
        base.SomeMethod();
       
        // Implémentation de la méthode
    }
}

Supposons qu'il existe une classe de base Shape, et que sa classe dérivée soit Rectangle :

Exemple

using System;
namespace InheritanceApplication
{
   class Shape
   {
      public void setWidth(int w)
      {
         width = w;
      }
      public void setHeight(int h)
      {
         height = h;
      }
      protected int width;
      protected int height;
   }

   // Classe dérivée
   class Rectangle: Shape
   {
      public int getArea()
      {
         return (width * height);
      }
   }
   
   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle Rect = new Rectangle();

         Rect.setWidth(5);
         Rect.setHeight(7);

         // afficher l'aire de l'objet
         Console.WriteLine("Aire totale : {0}", Rect.getArea());
         Console.ReadKey();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

总面积: 35

Initialisation de la classe de base

La classe dérivée hérite des variables membres et des méthodes membres de la classe de base. Par conséquent, l'objet de la classe parente doit être créé avant que l'objet de la classe enfant ne soit créé. Vous pouvez effectuer l'initialisation de la classe parente dans la liste d'initialisation des membres.

Le programme suivant le démontre :

Exemple

using System;
namespace RectangleApplication
{
   class Rectangle
   {
      // Variables membres
      protected double length;
      protected double width;
      public Rectangle(double l, double w)
      {
         longueur = l;
         width = w;
      }
      public double GetArea()
      {
         return length * width;
      }
      public void Display()
      {
         Console.WriteLine("Length: {0}", length);
         Console.WriteLine("Width: {0}", width);
         Console.WriteLine("Area: {0}", GetArea());
      }
   }//fin de la classe Rectangle  
   class Tabletop : Rectangle
   {
      private double cost;
      public Tabletop(double l, double w) : base(l, w)
      { }
      public double GetCost()
      {
         double cost;
         cost = GetArea() * 70;
         return cost;
      }
      public void Display()
      {
         base.Display();
         Console.WriteLine("Cost: {0}", GetCost());
      }
   }
   class ExecuteRectangle
   {
      static void Main(string[] args)
      {
         Tabletop t = new Tabletop(4.5, 7.5);
         t.Afficher();
         Console.ReadLine();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

长度: 4.5
宽度: 7.5
面积: 33.75
成本: 2362.5

Héritage d'interface

Une interface peut hériter d'une ou plusieurs autres interfaces, et l'interface dérivée hérite de tous les membres de l'interface de base.

Une interface dérivée peut étendre la liste des membres de l'interface de base, mais ne peut pas modifier leurs modificateurs d'accès.

Exemple

interface IBaseInterface
{
    void Method1();
}

interface IDerivedInterface : IBaseInterface
{
    void Method2();
}

L'héritage d'une interface peut être implémenté de la manière suivante :

Exemple

using System;

// définir une interface de base
interface IBaseInterface
{
    void Method1();
}

// Définir une interface dérivée qui hérite de l'interface de base
interface IDerivedInterface : IBaseInterface
{
    void Method2();
}

// Classe qui implémente l'interface dérivée
class MyClass : IDerivedInterface
{
    public void Method1()
    {
        Console.WriteLine("Implémentation de Method1");
    }

    public void Method2()
    {
        Console.WriteLine("Implémentation de Method2");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Créer une instance de la classe MyClass
        MyClass obj = new MyClass();

        // Appeler la méthode héritée de l'interface de base
        obj.Method1();

        // Appeler la méthode nouvellement ajoutée par l'interface dérivée
        obj.Method2();
    }
}

Dans l'exemple ci-dessus, la classe MyClass implémente l'interface IDerivedInterface, elle doit donc fournir toutes les méthodes définies dans IDerivedInterface, y compris la méthode Method1() héritée de IBaseInterface. Dans la méthode Main, nous créons une instance obj de MyClass et appelons ses méthodes.

Le résultat de sortie est:

Method1 implementation
Method2 implementation

Héritage multiple en C#

L'héritage multiple désigne la capacité d'une classe à hériter des comportements et des caractéristiques de plusieurs classes parentes en même temps. Contrairement à l'héritage simple, l'héritage simple signifie qu'une classe ne peut hériter que d'une seule classe parente.

C# ne prend pas en charge l'héritage multipleCependant, vous pouvez utiliser des interfaces pour implémenter l'héritage multiple. Le programme suivant le démontre :

Exemple

using System;
namespace InheritanceApplication
{
   class Shape
   {
      public void setWidth(int w)
      {
         width = w;
      }
      public void setHeight(int h)
      {
         height = h;
      }
      protected int width;
      protected int height;
   }

   // Classe de base PaintCost
   public interface PaintCost
   {
      int getCost(int area);

   }
   // Classe dérivée
   class Rectangle : Shape, PaintCost
   {
      public int getArea()
      {
         return (width * height);
      }
      public int getCost(int area)
      {
         return area * 70;
      }
   }
   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle Rect = new Rectangle();
         int area;
         Rect.setWidth(5);
         Rect.setHeight(7);
         area = Rect.getArea();
         // afficher l'aire de l'objet
         Console.WriteLine("Aire totale : {0}", Rect.getArea());
         Console.WriteLine("Coût total de la peinture : ${0}" , Rect.getCost(area));
         Console.ReadKey();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

总面积: 35
油漆总成本: $2450
autres extensions