Methodenüberschreibung in C#

Methodenüberschreibung ist eine häufig verwendete funktionale Operation in der C#-Programmierung, bei der es erforderlich ist, die in der Basisklasse definierten Operationen durch Verwendung der abgeleiteten Klasse zu überschreiben. Für ein erfolgreiches Überschreiben wird erwartet, dass es sich bei der Methode um eine statische Methode handelt, Mitgliedsklassifizierung und Zugriffsmodifikatoren sowohl in der Basis- als auch in der abgeleiteten Methode vom gleichen Typ sein sollten und das Überschreiben nur auf die abgeleitete Klasse und nicht auf die Basisklasse angewendet werden kann. Die anderen Namen für das Überschreiben von Methoden sind Laufzeitpolymorphismus, dynamischer Polymorphismus und späte Bindung.

Wie verwende ich das Überschreiben in C#?

Angenommen, unsere Anwendung muss das Verhalten der Basisklassenmethode in einer abgeleiteten Klasse ändern, dann sollten wir uns für eine Methodenüberschreibung entscheiden. Um dies zu erreichen, müssen wir die Methode in der abgeleiteten Klasse mit derselben Signatur in der Basisklasse erstellen, um eine andere Aufgabe auszuführen.  Bevor wir lernen, die Überschreibungstechnik anzuwenden, müssen wir die folgenden Punkte beachten.

• In der C#-Programmierung wird das Überschreiben von Methoden auch als Laufzeitpolymorphismus, späte Bindung oder dynamischer Polymorphismus bezeichnet.
• Methodenüberschreibungen sind nur in den abgeleiteten Klassen möglich. Weil eine Methode in der von der Basisklasse abgeleiteten Klasse überschrieben wird.
• Die Methode sollte eine nicht virtuelle oder statische Methode für eine Überschreibung sein.
• Der Zugriffsebenenmodifikator der Override-Methode und der virtuellen Methode sollte derselbe sein.

Die Methode, die durch die Override-Deklaration überschrieben wird, wird als überschriebene Basismethode bezeichnet. Dies wird in der Basisklasse vorhanden sein. Die überschriebene Basismethode kann entweder abstrakt, überschrieben oder virtuell sein. Neue Implementierung namens Override-Methode wird von dieser Basisklasse geerbt.

Wir verwenden verschiedene Schlüsselwörter zum Überschreiben von Methoden. Sie sind,

1. Virtuelles Schlüsselwort

Wenn der Compiler im Programm auf das Schlüsselwort virtual stößt, versteht er, dass diese Methode von jeder seiner abgeleiteten Klassen überschrieben werden kann. Die Struktur ist wie folgt.

public virtual int EnemyHealth()
{
Console.WriteLine("Enemy Health");
}

2. Schlüsselwort überschreiben

Dies ist in der abgeleiteten Klasse vorhanden. Es teilt dem Compiler mit, dass diese Methode die Methode mit demselben Namen und derselben Signatur in der Basisklasse überschreibt.

public override int EnemyHealth ()
{
Console.WriteLine("Enemy 1");
}

Beispiel

Schauen wir uns zunächst das Beispiel an, ohne die Schlüsselwörter „Virtual“ und „override“ zu verwenden.

Code:

class Birds
{
public void Color( )
{
Console.WriteLine("Birds will have different Colors");
}
}
class Parrot:Birds
{
public void Color( )
{
Console.WriteLine("Parrot is Green");
}
}
class ExecutionClass
{
public static void Main( )
{
Birds object;
object = new Birds( );
object .Color( );
object = new Parrot( );
object.Color( );
}
}

Ausgabe:

Im obigen Beispiel haben wir ein Objekt der abgeleiteten Klasse „Parrot“ erstellt und seine Referenz im Referenzvariablenobjekt vom Typ „Birds“ gespeichert.

Im nächsten Schritt rufen wir mithilfe des Referenzvariablenobjekts die Funktion „Color()“ auf. Da „object“ einen Verweis auf ein Objekt vom Typ „Parrot“ enthält, erwarten wir natürlich, dass die Funktion „Color()“ der Klasse „Parrot“ ausgeführt wird. Aber wir liegen falsch. Die Schönheit der Programmierung lässt es nicht zu.

Zu unserer Überraschung wird die Color()-Methode der Birds-Klasse ausgeführt. Das liegt daran, dass die Funktion basierend auf der Art der Referenz aufgerufen wird und nicht darauf, worauf das Referenzvariablenobjekt verweist. Da es sich bei dem Objekt um eine Referenz vom Typ Birds handelt, wird die Funktion Color() der Klasse Birds aufgerufen, unabhängig davon, auf wen sich das Objekt bezieht.

Jetzt schreiben wir dasselbe Programm mit Virtual und Override neu. Dieses Mal gehen wir zum besseren Verständnis Schritt für Schritt vor.

Erstellen Sie eine Basisklasse mit einem beliebigen Namen. Hier verwende ich Birds. Schreiben Sie eine Methode mit dem Schlüsselwort virtual. Dies wird unsere überschriebene Methode sein, die wir in der geerbten Klasse überschreiben. Schreiben Sie innerhalb der Methode eine Nachricht, die in der Konsole gedruckt werden soll.

class Birds
{
public virtual void Color( )
{
Console.WriteLine("Birds will have different Colors");
}
}

Erstellen Sie nun eine weitere Klasse Parrot. Dieses Mal erben wir sie von der Basisklasse, die wir zuvor erstellt haben, d. h. Birds. Zum Vererben verwenden wir das Symbol „:“.

Klasse Papagei: Vögel

Schreiben Sie hier eine Funktion mit dem Schlüsselwort „override“ und schreiben Sie eine Nachricht. Stellen Sie sicher, dass der Methodenname und die Signatur in der abgeleiteten Klasse mit dem Methodennamen und der Signatur in der Basisklasse übereinstimmen.

public override void Color ( )
{
Console.WriteLine("Parrot is Green");
}

Wir benötigen eine weitere Klasse, um die Funktionalität zum Überprüfen des Überschreibens auszuführen. Erstellen Sie eine Klasse mit einem beliebigen Namen. Schreiben Sie darin die Hauptfunktion.

class ExecutionClass
{
public static void Main( )
{
}
}

Erstellen Sie ein Objekt der übergeordneten Klasse und lösen Sie die Funktion mithilfe des Objekts der Klasse aus. Dadurch wird die in der Birds-Klasse vorhandene Color-Methode aufgerufen.

Birds object;
object = new Birds( );
object .Color( );

Erstellen Sie nun das Objekt der abgeleiteten Klasse und rufen Sie die Color-Methode auf. Dadurch wird die Color-Methode der Parrot-Klasse aufgerufen.

object = new Parrot( );
object.Color( );

Können Sie die Ausgabe erraten, wenn wir das Programm ausführen? Dies ist wie unten gezeigt.

Ausgabe:

Die Schlüsselwörter override und virtual ermöglichen den separaten Aufruf der Basisklasse und der abgeleiteten Klassenmethoden zu jedem Zeitpunkt, auch wenn die Methodennamen und Signaturen gleich sind.

Fazit

In diesem Artikel haben wir das Methodenüberschreiben, die Notwendigkeit des Methodenüberschreibens, reale Beispiele des Überschreibungsprinzips, die Art und Weise, es zu erreichen, die Notwendigkeit der Verwendung der Schlüsselwörter virtual und override und das Beispiel des Überschreibens mithilfe des Codes verstanden . Wir können daraus schließen, dass das Überschreiben eine der nützlichen Funktionen des Polymorphismus ist, mit der wir das Verhalten der Basisklassenmethode in der abgeleiteten Klasse ändern können.

Das obige ist der detaillierte Inhalt vonMethodenüberschreibung in C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!