C# - Overerving

Een van de belangrijkste concepten in objectgeoriënteerd programmeren is overerving. Overerving stelt ons in staat om een ​​klasse te definiëren in termen van een andere klasse, wat het gemakkelijker maakt om een ​​applicatie te maken en te onderhouden. Dit biedt ook de mogelijkheid om de codefunctionaliteit opnieuw te gebruiken en versnelt de implementatietijd.

Bij het maken van een klasse kan de programmeur, in plaats van volledig nieuwe gegevensleden en lidfuncties te schrijven, aangeven dat de nieuwe klasse de leden van een bestaande klasse moet erven. Deze bestaande klasse wordt de basis . genoemd klasse, en de nieuwe klasse wordt de afgeleide . genoemd klasse.

Het idee van overerving implementeert de IS-A relatie. Bijvoorbeeld, zoogdier IS A dier, hond IS-A zoogdier vandaar hond IS-A ook dieren, enzovoort.

Basisklassen en afgeleide klassen

Een klasse kan worden afgeleid van meer dan één klasse of interface, wat betekent dat deze gegevens en functies kan erven van meerdere basisklassen of interfaces.

De syntaxis die in C# wordt gebruikt voor het maken van afgeleide klassen is als volgt −

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

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

Overweeg een basisklasse Vorm en zijn afgeleide klasse Rechthoek −

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

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

Total area: 35

Basisklasse initialiseren

De afgeleide klasse erft de lidvariabelen en lidmethoden van de basisklasse. Daarom moet het superklasse-object worden gemaakt voordat de subklasse wordt gemaakt. U kunt instructies voor de initialisatie van superklassen geven in de initialisatielijst voor leden.

Het volgende programma demonstreert dit −

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

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

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

Meerdere overerving in C#

C# ondersteunt geen meervoudige overerving . U kunt echter interfaces gebruiken om meervoudige overerving te implementeren. Het volgende programma demonstreert dit −

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

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

Total area: 35
Total paint cost: $2450