C# Vererbung

Vererbung ist eines der wichtigsten Konzepte in der objektorientierten Programmierung. Vererbung ermöglicht es uns, eine weitere Klasse auf Basis einer Klasse zu definieren, was das Erstellen und Warten von Anwendungen erleichtert. Sie erleichtert außerdem die Wiederverwendung von Code und spart Entwicklungszeit.

Beim Erstellen einer Klasse muss der Programmierer nicht alle neuen Datenelemente und Memberfunktionen vollständig neu schreiben; er muss lediglich eine neue Klasse entwerfen, die die Member einer vorhandenen Klasse erbt. Diese vorhandene Klasse wird als dieBasisklasse bezeichnet, diese neue Klasse wird alsabgeleitete Klasse bezeichnet。

Das Konzept der Vererbung implementiertIst-ein (IS-A)Beziehung. Zum Beispiel: SäugetiereIst-ein (IS-A)Tier, HundIst-ein (IS-A)Säugetiere, daher HundeIst-ein (IS-A)Tier.

Basisklassen und abgeleitete Klassen

Eine Klasse kann von einer anderen Klasse erben; dabei wird die eine als Basisklasse (Elternklasse) und die andere als abgeleitete Klasse (Kindklasse) bezeichnet.

C# unterstützt keine Mehrfachvererbung von Klassen, aber es unterstützt die Mehrfachvererbung von Schnittstellen; eine Klasse kann mehrere Schnittstellen implementieren.

Zusammenfassung:Eine Klasse kann von mehreren Schnittstellen erben, aber nur von einer Klasse erben.

Die Syntax zum Erstellen einer abgeleiteten Klasse in C# lautet wie folgt:

<Zugriffsmodifikatoren> class <Basisklasse>
{
 ...
}
class <abgeleitete Klasse> : <Basisklasse>
{
 ...
}

Eine abgeleitete Klasse erbt die Member der Basisklasse (Felder, Methoden, Eigenschaften usw.), es sei denn, sie sind explizit als private gekennzeichnet.

Eine abgeleitete Klasse kann die Konstruktoren und Methoden der Basisklasse über das Schlüsselwort `base` aufrufen.

Beispiel

class BaseClass
{
    public void SomeMethod()
    {
        // Methodenimplementierung
    }
}

class DerivedClass : BaseClass
{
    public void AnotherMethod()
    {
        // Zugriff auf Basisklassenmethode
        base.SomeMethod();
       
        // Methodenimplementierung
    }
}

Angenommen, es gibt eine Basisklasse Shape, und ihre abgeleitete Klasse ist Rectangle:

Beispiel

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

   // Abgeleitete Klasse
   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);

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

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis:

总面积: 35

Initialisierung der Basisklasse

Die abgeleitete Klasse erbt die Membervariablen und Membermethoden der Basisklasse. Daher sollte das Objekt der Elternklasse erstellt werden, bevor das Objekt der Kindklasse erstellt wird. Sie können die Initialisierung der Elternklasse in der Memberinitialisierungsliste durchführen.

Das folgende Programm demonstriert dies:

Beispiel

using System;
namespace RectangleApplication
{
   class Rectangle
   {
      // Membervariablen
      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("Länge: {0}", length);
         Console.WriteLine("Breite: {0}", width);
         Console.WriteLine("Fläche: {0}", GetArea());
      }
   }//Ende der Klasse 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.Anzeigen();
         Console.ReadLine();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis:

长度: 4.5
宽度: 7.5
面积: 33.75
成本: 2362.5

Schnittstellenvererbung

Eine Schnittstelle kann von einer oder mehreren anderen Schnittstellen erben, und die abgeleitete Schnittstelle erbt alle Member der Basisschnittstelle.

Eine abgeleitete Schnittstelle kann die Memberliste der Basisschnittstelle erweitern, aber nicht deren Zugriffsmodifizierer ändern.

Beispiel

interface IBaseInterface
{
    void Method1();
}

interface IDerivedInterface : IBaseInterface
{
    void Method2();
}

Die Vererbung einer Schnittstelle kann auf folgende Weise implementiert werden:

Beispiel

using System;

// Basis-Schnittstelle definieren
interface IBaseInterface
{
    void Method1();
}

// Abgeleitete Schnittstelle definieren, die von der Basis-Schnittstelle erbt
interface IDerivedInterface : IBaseInterface
{
    void Method2();
}

// Klasse, die die abgeleitete Schnittstelle implementiert
class MyClass : IDerivedInterface
{
    public void Method1()
    {
        Console.WriteLine("Method1-Implementierung");
    }

    public void Method2()
    {
        Console.WriteLine("Method2-Implementierung");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Instanz der MyClass-Klasse erstellen
        MyClass obj = new MyClass();

        // Methode aufrufen, die von der Basis-Schnittstelle geerbt wurde
        obj.Method1();

        // Methode aufrufen, die von der abgeleiteten Schnittstelle neu hinzugefügt wurde
        obj.Method2();
    }
}

Im obigen Beispiel implementiert die Klasse MyClass die Schnittstelle IDerivedInterface, daher muss sie alle in IDerivedInterface definierten Methoden bereitstellen, einschließlich der von IBaseInterface geerbten Methode Method1(). In der Methode Main erstellen wir eine Instanz obj von MyClass und rufen ihre Methoden auf.

Das Ausgabeergebnis ist:

Method1 implementation
Method2 implementation

C# Mehrfachvererbung

Mehrfachvererbung bezeichnet die Fähigkeit einer Klasse, Verhaltensweisen und Eigenschaften gleichzeitig von mehr als einer Elternklasse zu erben. Im Gegensatz zur Einfachvererbung bedeutet Einfachvererbung, dass eine Klasse nur von einer Elternklasse erben kann.

C# unterstützt keine MehrfachvererbungSie können jedoch Schnittstellen verwenden, um Mehrfachvererbung zu implementieren. Das folgende Programm demonstriert dies:

Beispiel

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

   // Basisklasse PaintCost
   public interface PaintCost
   {
      int getCost(int area);

   }
   // Abgeleitete Klasse
   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();
         // die Fläche des Objekts ausgeben
         Console.WriteLine("Gesamtfläche: {0}", Rect.getArea());
         Console.WriteLine("Gesamte Lackierkosten: ${0}" , Rect.getCost(area));
         Console.ReadKey();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis:

总面积: 35
油漆总成本: $2450
Weitere Erweiterungen