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 classe en fonction d'une autre classe, ce qui facilite la création et la maintenance d'une application. Cela permet également de réutiliser la fonctionnalité de code et d'accélérer le temps de mise en œuvre.

Lors de la création d'une classe, au lieu d'écrire des membres de données et des fonctions membres entièrement nouveaux, le programmeur peut indiquer que la nouvelle classe doit hériter des membres d'une classe existante. Cette classe existante est appelée la base classe, et la nouvelle classe est appelée dérivée classe.

L'idée d'héritage implémente l'IS-A relation. Par exemple, le mammifère IS A animal, chien IS-A mammifère donc chien IS-A animal aussi, et ainsi de suite.

Classes de base et dérivées

Une classe peut être dérivée de plusieurs classes ou interfaces, ce qui signifie qu'elle peut hériter des données et des fonctions de plusieurs classes ou interfaces de base.

La syntaxe utilisée en C# pour créer des classes dérivées est la suivante −

<acess-specifier> class <base_class> {
   ...
}

class <derived_class> : <base_class> {
   ...
}

Considérons une classe de base Shape et sa classe dérivée Rectangle −

Démo en direct

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;
   }

   // Derived class
   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);

         // Print the area of the object.
         Console.WriteLine("Total area: {0}",  Rect.getArea());
         Console.ReadKey();
      }
   }
}

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

Total area: 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 super classe doit être créé avant la création de la sous-classe. Vous pouvez donner des instructions pour l'initialisation de la superclasse dans la liste d'initialisation des membres.

Le programme suivant le démontre −

Démo en direct

using System;

namespace RectangleApplication {
   class Rectangle {
      
      //member variables
      protected double length;
      protected double width;
      
      public Rectangle(double l, double w) {
         length = 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());
      }
   }//end class 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.Display();
         Console.ReadLine();
      }
   }
}

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

Length: 4.5
Width: 7.5
Area: 33.75
Cost: 2362.5

Héritage multiple en C#

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

Démo en direct

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;
   }

   // Base class PaintCost
   public interface PaintCost {
      int getCost(int area);
   }
   
   // Derived class
   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();
         
         // Print the area of the object.
         Console.WriteLine("Total area: {0}",  Rect.getArea());
         Console.WriteLine("Total paint cost: ${0}" , Rect.getCost(area));
         Console.ReadKey();
      }
   }
}

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

Total area: 35
Total paint cost: $2450