Überschreiben in C#

Überschreiben in C# ist die Neuimplementierung einer Basisklassenmethode in einer abgeleiteten Klasse. Dabei wird die Basisklassenmethode in der untergeordneten Klasse überschrieben. Die abgeleitete Klassenmethode hat denselben Namen und dieselbe Signatur wie die Basisklassenmethode. Das Überschreiben ist nützlich, um Laufzeitpolymorphismus zu erreichen.

Es gibt einige Schlüsselwörter, die beim Überschreiben von Methoden verwendet werden.

1. Virtual – Dieses Schlüsselwort wird mit einer Basisklasse verwendet, was bedeutet, dass die Methode einer Basisklasse überschrieben werden kann.

public virtual void Method()
{
// implementation
}

2. Überschreiben – Dieses Schlüsselwort wird mit einer abgeleiteten Klasse verwendet, was bedeutet, dass die abgeleitete Klasse eine Methode einer Basisklasse überschreibt.

public override void Method()
{
// implementation
}

3. Basis – Dieses Schlüsselwort wird in einer abgeleiteten Klasse verwendet, um die Basisklassenmethode aufzurufen.

public override void Method()
{
base.Method();
// implementation
}

Wie funktioniert das Überschreiben in C#?

Unten finden Sie ein Beispiel dafür, wie wir das Überschreiben in C# implementieren können.

class Parent
{
public virtual void Demo()  // base class
{
Console.WriteLine(“This is parent”);
}
}
class Child: Parent
{
public override void Demo()  // derived class
{
Console.WriteLine(“This is child”);
}
}

Im obigen Beispiel gibt es zwei Klassen, eine ist die Basisklasse oder übergeordnete Klasse und die andere ist eine abgeleitete Klasse oder wir können sagen, eine untergeordnete Klasse. Eine Basisklassenmethode wird in der untergeordneten Klasse abgeleitet. Dabei ist die Methode in einer übergeordneten Klasse virtuell, was bedeutet, dass sie von der untergeordneten Klasse überschrieben werden kann. Überschreiben in einem untergeordneten Element bedeutet, dass diese Methode mit der Methode der übergeordneten Klasse mit derselben Methodensignatur identisch ist.

Arten des Überschreibens in C#

Unten finden Sie Beispiele, die das Überschreiben mit verschiedenen Schlüsselwörtern zeigen.

Beispiel 1 – Ohne virtuelle und überschriebene Schlüsselwörter

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
{
class Bird   // base class
{
public void fly()  // base class method
{
Console.WriteLine("Birds are flying");
}
}
class Peacock : Bird   // derived class
{
public new void fly()  // derived class method
{
Console.WriteLine("Peacock is flying");
}
}
class Program
{
// main method
static void Main(string[] args)
{
Bird b = new Peacock();
b.fly();
Console.ReadLine();
}
}
}

Im obigen Beispiel wird weder in den Basismethoden noch in den abgeleiteten Methoden ein Schlüsselwort verwendet.

Auch in der Hauptmethode wird die übergeordnete Referenz verwendet, um die untergeordnete Methode aufzurufen. Wenn also in diesem Fall kein Schlüsselwort verwendet wird, wird die übergeordnete Methode anstelle einer untergeordneten Methode aufgerufen. Die Ausgabe lautet also

Ausgabe:

Beispiel 2 (a) – Mit virtuellen und Override-Schlüsselwörtern

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
{
class Bird   // base class
{
public virtual void fly()   // base class method
{
Console.WriteLine("Birds are flying");
}
}
class Peacock : Bird   // derived class
{
public override void fly()   // derived class method
{
Console.WriteLine("Peacock is flying");
}
}
class Program
{
// main method
static void Main(string[] args)
{
Bird b = new Peacock();
b.fly();
Console.ReadLine();
}
}
}

In diesem Beispiel wird „virtual“ in der Basisklasse verwendet, was bedeutet, dass es der untergeordneten Klasse die Berechtigung gibt, die Methode auf ihre eigene Weise zu implementieren. In einer abgeleiteten Klasse wird Override verwendet, was bedeutet, dass die untergeordnete Methode die Override-Methode ist. Beide Methoden sind identisch, haben denselben Namen und dieselbe Methodensignatur, aber der Implementierungsteil ist unterschiedlich. Auch in diesem Beispiel wird die übergeordnete Referenz verwendet, um die untergeordnete Methode aufzurufen. Da es sich bei einer übergeordneten Methode jedoch um eine virtuelle Methode handelt, wird zuerst die untergeordnete Methode und nicht die übergeordnete Methode aufgerufen. Die Ausgabe lautet also

Ausgabe:

Beispiel 2 (b) – Virtuelle und Override-Schlüsselwörter

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
{
class Bird  // base class
{
public virtual void fly()   // base class method
{
Console.WriteLine("Birds are flying");
}
}
class Peacock : Bird   // derived class
{
public override void fly()  // derived class method
{
Console.WriteLine("Peacock is flying");
}
}
class Program
{
//main method
static void Main(string[] args)
{
Peacock p = new Peacock();
p.fly();
Console.ReadLine();
}
}
}

Dieses Beispiel ist das gleiche wie das vorherige Beispiel, aber diese untergeordnete Methode wird als Referenz verwendet.

Ausgabe: 

Beispiel 3 – Mit Basisschlüsselwort

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
{
class Bird  // base class
{
public virtual void fly()  // base class method
{
Console.WriteLine("Birds are flying");
}
}
class Peacock : Bird  // derived class
{
public override void fly()  // derived class method
{
base.fly();  // base is use to call parent method
Console.WriteLine("Peacock is flying");
}
}
class Program
{
static void Main(string[] args)
{
Peacock p = new Peacock();
p.fly();
Console.ReadLine();
}
}
}

Im obigen Beispiel wird die Basis in einer abgeleiteten Klasse verwendet, um die Basisklassenmethode aufzurufen. In dieser wird also zuerst die Basismethode und dann die abgeleitete Methode aufgerufen.

Ausgabe:

Beispiel 4 – Abstrakte Klassen mit Überschreibung

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
{
abstract class Calculate
{
public abstract int sum();
}
class Values : Calculate // derived class
{
int val1;
int val2;
public Values(int a = 0, int b = 0)
{
val1 = a;
val2 = b;
}
public override int sum()
{
Console.WriteLine("sum of two values");
return (val1 + val2);
}
}
class Program
{
static void Main(string[] args)
{
Values v = new Values(10, 20);
int a = v.sum();
Console.WriteLine(a);
Console.ReadLine();
}
}
}

Im obigen Beispiel wird eine abstrakte Methode verwendet. Eine abstrakte Klasse wird durch die abgeleitete Klasse implementiert, die eine abstrakte Methode enthält.

Ausgabe: 

Regeln für das Überschreiben von Methoden

• Die Methodensignatur einer abgeleiteten Klasse sollte mit der einer Basisklasse identisch sein.
• Überschreiben ist in derselben Klasse nicht möglich.
• Zugriffsmodifikatoren müssen für virtuelle Methoden und Überschreibungsmethoden gleich sein.
• Das Schlüsselwort virtual wird in der Basisklassenmethode und Override in einer abgeleiteten Klassenmethode verwendet.
• Die Basisklassenmethode sollte nicht statisch sein.

Fazit

Überschreiben ist beim Laufzeitpolymorphismus nützlich. Es ermöglicht abgeleiteten Klassen, eine Basisklassenmethode auf ihre eigene Weise zu implementieren. Daher unterscheidet sich die Methodenimplementierung der abgeleiteten Klasse von ihrer Basisklasse. Die überschriebene Methode kann virtuell, überschrieben oder abstrakt sein.

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