C #: ereditarietà

Uno dei concetti più importanti nella programmazione orientata agli oggetti è l'ereditarietà. L'ereditarietà ci consente di definire una classe in termini di un'altra classe, il che semplifica la creazione e la manutenzione di un'applicazione. Ciò offre anche l'opportunità di riutilizzare la funzionalità del codice e accelera i tempi di implementazione.

Quando si crea una classe, invece di scrivere membri dati e funzioni membro completamente nuovi, il programmatore può designare che la nuova classe erediti i membri di una classe esistente. Questa classe esistente è chiamatabase class e la nuova classe è indicata come derived classe.

L'idea di eredità implementa il IS-Arelazione. Ad esempio, mammiferoIS A animale, cane IS-A mammifero quindi cane IS-A anche animali, e così via.

Classi di base e derivate

Una classe può essere derivata da più di una classe o interfaccia, il che significa che può ereditare dati e funzioni da più classi o interfacce di base.

La sintassi utilizzata in C # per la creazione di classi derivate è la seguente:

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

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

Considera una classe di base Shape e la sua classe derivata 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();
      }
   }
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Total area: 35

Inizializzazione della classe di base

La classe derivata eredita le variabili del membro della classe base ei metodi del membro. Pertanto l'oggetto della super classe dovrebbe essere creato prima della creazione della sottoclasse. È possibile fornire istruzioni per l'inizializzazione della superclasse nell'elenco di inizializzazione dei membri.

Il seguente programma lo dimostra:

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

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

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

Ereditarietà multipla in C #

C# does not support multiple inheritance. Tuttavia, è possibile utilizzare le interfacce per implementare più ereditarietà. Il seguente programma lo dimostra:

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

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Total area: 35
Total paint cost: $2450