Latest web development tutorials

C # Vererbung

Vererbung ist eine objektorientierte Programmierung einer der wichtigsten Begriffe ist. Die Vererbung ermöglicht es uns, eine Klasse zu definieren, die auf eine andere Klasse zugrunde, eine Klasse zu definieren, die die Schaffung macht und Pflege von Anwendungen viel einfacher. Aber auch förderlich für die Wiederverwendung von Code und die Entwicklungszeit verkürzen.

Wenn Sie eine Klasse erstellen, Programmierer brauchen nicht vollständig auf neue Funktionen Datenelemente und Mitglied neu zu schreiben, müssen Sie nur eine neue Klasse zu entwerfen, die die bestehenden Mitglieder der Klasse erbt sein kann. Die bestehendeBasisklasse ist eine Klasse genannt, wird die neue Klasse die abgeleitete Klasse genannt.

Die Realisierung der Idee der VererbungZugehörigkeit (IS-A) Beziehung.Zum Beispielgehört ein Säugetier (IS-A)Tiere, Hundegehören,(IS-A)von Säugetieren, und daherzudem Hundgehören (IS-A)Tiere.

Basis- und abgeleiteten Klassen

Eine Klasse kann aus mehr als einer Klasse oder Schnittstelle abgeleitet werden, was bedeutet, dass es mehrere Basisklassen oder Schnittstellen von Daten und Funktionen erben können.

Erstellen Sie eine abgeleitete Klasse in C # Syntax lautet wie folgt: 

<Acess-specifier> Klasse <base_class>
{
 ...
}
Klasse <derived_class>: <base_class>
{
 ...
}

Nehmen wir an, es ist eine Basisklasse Form, das ist die abgeleitete Klasse Rechteck: 

using System;
Namespace InheritanceApplication
{
   Klasse-Form 
   {
      public void setWidth (int w)
      {
         width = w;
      }
      public void setHeight (int h)
      {
         height = h;
      }
      geschützt int Breite;
      geschützt int Höhe;
   }

   // Abgeleitete Klasse Klasse Rectangle: Form
   {
      public int getArea ()
      { 
         Rückkehr (Breite * Höhe); 
      }
   }
   
   Klasse RectangleTester
   {
      static void Main (string [] args)
      {
         Rechteck Rect = new Rectangle ();

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

         // Druckfläche des Objekts Console.WriteLine ( "Die Gesamtfläche: {0}", Rect.getArea ());
         Console.ReadKey ();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse: 

Gesamtfläche: 35

Initialisieren der Basisklasse

Abgeleitete Klasse erbt Elementvariablen und Mitglied Methoden der Basisklasse. Daher sollte das übergeordnete Objekt erstellt werden, bevor ein Objekt der Unterklasse erstellt wurde. Sie können die Elternklasse in der Initialisierungsliste initialisieren.

Das folgende Programm veranschaulicht diesen Punkt: 

using System;
Namespace RectangleApplication
{
   Klasse Rectangle
   {
      // Member Variablen doppelter Länge geschützt;
      doppelte Breite geschützt;
      public Rectangle (Doppel l, Doppel w)
      {
         Länge = l;
         width = w;
      }
      public double GetArea ()
      {
         Rückkehr Länge * Breite;
      }
      public void Display ()
      {
         Console.WriteLine ( "Länge: {0}", Länge);
         Console.WriteLine ( "Breite: {0}", Breite);
         Console.WriteLine ( "Größe: {0}", GetArea ());
      }
   } // Ende der Klasse Rectangle  
   Klasse Tabletop: Rectangle
   {
      private Doppel Kosten;
      öffentliche Tabletop (Doppel l, Doppel w): Basis (l, w)
      {}
      public double GetCost ()
      {
         doppelte Kosten;
         Kosten = GetArea () * 70;
         Rückkehr Kosten;
      }
      public void Display ()
      {
         base.Display ();
         Console.WriteLine ( "Kosten: {0}", GetCost ());
      }
   }
   Klasse ExecuteRectangle
   {
      static void Main (string [] args)
      {
         Tabletop t = new Tabletop (4.5, 7.5);
         t.Display ();
         Console.ReadLine ();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse: 

Länge: 4,5
Breite: 7.5
Gebiet: 33.75
Kosten: 2362,5

C # Mehrfachvererbung

C # unterstützt keine Mehrfachvererbung.Sie können jedoch die Schnittstelle verwenden, um Mehrfachvererbung erreichen. Das folgende Programm veranschaulicht diesen Punkt: 

using System;
Namespace InheritanceApplication
{
   Klasse-Form 
   {
      public void setWidth (int w)
      {
         width = w;
      }
      public void setHeight (int h)
      {
         height = h;
      }
      geschützt int Breite;
      geschützt int Höhe;
   }

   // Basisklasse Paintcost
   öffentliche Schnittstelle Paintcost 
   {
      int getCost (int Bereich);

   }
   // Abgeleitete Klasse Klasse Rechteck: Form, Paintcost
   {
      public int getArea ()
      {
         Rückkehr (Breite * Höhe);
      }
      public int getCost (int-Bereich)
      {
         Rückgabebereich * 70;
      }
   }
   Klasse RectangleTester
   {
      static void Main (string [] args)
      {
         Rechteck Rect = new Rectangle ();
         int Bereich;
         Rect.setWidth (5);
         Rect.setHeight (7);
         area = Rect.getArea ();
         // Druckfläche des Objekts Console.WriteLine ( "Die Gesamtfläche: {0}", Rect.getArea ());
         Console.WriteLine ( "Malen Gesamtkosten: $ {0}", Rect.getCost (Gebiet));
         Console.ReadKey ();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse: 

Gesamtfläche: 35
Malen Gesamtkosten: $ 2.450