C # - Héritage

L'un des concepts les plus importants de la programmation orientée objet est l'héritage. L'héritage nous permet de définir une classe en termes d'une autre classe, ce qui facilite la création et la maintenance d'une application. Cela permet également de réutiliser la fonctionnalité du 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 complètement nouveaux, le programmeur peut désigner que la nouvelle classe doit hériter des membres d'une classe existante. Cette classe existante s'appelle lebase class, et la nouvelle classe est appelée derived classe.

L'idée d'héritage met en œuvre le IS-Arelation. Par exemple, mammifèreIS 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 de base ou interfaces.

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 -

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 de la classe de base et des méthodes membres. Par conséquent, l'objet de 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 -

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# does not support multiple inheritance. Cependant, vous pouvez utiliser des interfaces pour implémenter l'héritage multiple. Le programme suivant le démontre -

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