Einführung in das virtuelle Schlüsselwort in C #
Was ist das virtuelle Schlüsselwort? Bevor Sie direkt in die C # -Perspektive springen, ist es wichtig, das Konzept von Vererbung, Überschreiben und virtuellem Schlüsselwort in der objektorientierten Programmierwelt zu verstehen oder zu überarbeiten.
Method Overriding ist ein OOP-Konzept, das eng mit Inheritance verknüpft ist. Wenn eine untergeordnete Klassenmethode die übergeordnete Klassenmethode mit demselben Namen, denselben Parametern und demselben Rückgabetyp überschreibt, wird dies als Methodenüberschreibung bezeichnet. Ein virtuelles Schlüsselwort gibt dem Compiler an, dass eine Methode in abgeleiteten Klassen überschrieben werden kann.
In der C # -Perspektive wird das Schlüsselwort virtual verwendet, um die Deklaration einer Eigenschaft, einer Methode oder eines Ereignisses so zu ändern, dass das Überschreiben in einer abgeleiteten Klasse möglich ist. In einfachen Worten, das Schlüsselwort virtual implementiert das Konzept des Überschreibens der Methode in C #.
Syntax
Jede Eigenschaft, Methode oder jedes Ereignis kann überschrieben werden, indem das virtuelle Schlüsselwort in der Basisklasse hinzugefügt und das Schlüsselwort in der abgeleiteten Klasse überschrieben wird.
Fügen Sie das virtuelle Schlüsselwort in die Basisklassendeklaration ein:
public class Base (
public virtual int abc ( get; set; ) // this property can be overridden
public virtual void Xyz() ( ) // this method can be overridden
)
Fügen Sie das Schlüsselwort override in die Basisklassendeklaration ein:
public class Derived : Base (
public override int abc ( get; set; ) // this overrides the base class property
public override void Xyz() ( ) // this overrides the base class method
)
Wie funktioniert Virtual in C #?
Der grundlegende Unterschied zwischen Überladen und Überschreiben besteht darin, dass Ersteres ein Mechanismus zur Kompilierungszeit ist, während Letzteres zur Laufzeit ins Spiel kommt. Ein virtuelles Schlüsselwort wird zur Laufzeit aktiviert und implementiert so das übergeordnete Konzept der Methode.
Wenn eine virtuelle Methode oder Eigenschaft aufgerufen oder darauf zugegriffen wird, sucht der Compiler nach einem überschreibenden Mitglied der Methode oder der Eigenschaft. Wenn einer gefunden wird, wird er aufgerufen. Wird keine gefunden, wird die ursprüngliche Methode oder Eigenschaft aufgerufen.
Hier stellt sich eine hervorragende Frage: Was passiert bei der mehrstufigen Vererbung? Wenn ein Klassenmitglied in mehr als einer Ebene überschrieben wird, wird das tiefste überschriebene Mitglied aufgerufen (dasjenige in der am meisten abgeleiteten Klasse).
Beispiel
Das folgende Beispiel für ein virtuelles Schlüsselwort in C # wird unten aufgeführt
Einstufige Vererbung
Nehmen wir ein Beispiel, um die Funktionsweise eines virtuellen Schlüsselworts zu verstehen, wenn eine einzelne untergeordnete Klasse die übergeordnete Klasse erbt, dh es gibt keine mehrstufige Vererbung.
using System;
public class Polynomial
(
public virtual double len
(
get;
set;
)
public virtual double wid
(
get;
set;
)
public virtual double Area()
(
return len * wid;
)
)
public class Rectangle: Polynomial
(
)
public class Square : Polynomial
(
public override double len
(
get;
set;
)
public override double Area()
(
return len * len;
)
)
public class Circle : Polynomial
(
public double radius
(
get;
set;
)
public override double Area()
(
return Math.PI * radius * radius;
)
)
public class Triangle : Polynomial
(
public override double Area()
(
return 0.5 * len * wid;
)
)
public class Program
(
public static void Main()
(
var rect = new Rectangle();
rect.len = 5;
rect.wid = 10;
Console.WriteLine("Area of Rectangle = " + rect.Area());
var sq = new Square();
sq.len = 15;
Console.WriteLine("Area of Square = " + sq.Area());
var cir = new Circle();
cir.radius = 10;
Console.WriteLine("Area of Circle = " + cir.Area());
var tri = new Triangle();
tri.len = 5;
tri.wid = 10;
Console.WriteLine("Area of Triangle = " + tri.Area());
)
)
Wie funktioniert der obige Code?
In der Basisklasse Polynomial haben wir zwei Eigenschaften und eine Methode als virtuell deklariert. Diese können jetzt in untergeordneten Klassen überschrieben werden. Jetzt erstellen wir verschiedene untergeordnete Klassen mit unterschiedlichen Formen, die die Polynomklasse erben.
In der Rectangle-Klasse müssen wir keine Eigenschaft oder Methode überschreiben. Die Basisklassenimplementierung würde so funktionieren, wie sie für die Rectangle-Klasse ist.
In der Square-Klasse verfügen wir nicht über die width-Eigenschaft. Daher überschreiben wir die Eigenschaft length und die Methode Area, um das Quadrat der Länge zurückzugeben.
In der Circle-Klasse haben wir weder Länge noch Breite. Daher deklarieren wir eine neue klassenspezifische Eigenschaft des Radius und überschreiben die Area-Methode entsprechend.
In der Triangle-Klasse überschreiben wir einfach die Area-Methode und die Eigenschaften werden von dem Polynom der Basisklasse geerbt.
Wenn wir Objekte der abgeleiteten Klassen erstellen, stößt der Compiler beim Aufbau der Basisklasse auf das virtuelle Schlüsselwort und sucht daher nach den überschriebenen Mitgliedern. Die überschriebenen Mitglieder werden dann entsprechend aufgerufen.
Mehrstufige Vererbung
Lassen Sie uns das obige Beispiel ändern, um die Vererbung auf mehreren Ebenen einzuschließen.
using System;
public class Polynomial
(
public virtual double len ( get; set; )
public virtual double wid ( get; set; )
public virtual double Area()
( return 0; )
)
public class Rectangle : Polynomial
(
public override double Area()
( return len * wid; )
)
public class Square : Rectangle
(
public override double len ( get; set; )
public override double Area()
( return len * len; )
)
public class Program
(
public static void Main()
(
var rect = new Rectangle();
rect.len = 5;
rect.wid = 10;
Console.WriteLine("Area of Rectangle = " + rect.Area());
var sq = new Square();
sq.len = 15;
Console.WriteLine("Area of Square = " + sq.Area());
)
)
Vorteile
Ein virtuelles Member verfügt sowohl in der Basisklasse als auch in den abgeleiteten Klassen über Deklarationen und Definitionen. Virtuelle Mitglieder sind von Vorteil, wenn in den abgeleiteten Klassen einige zusätzliche Funktionen erforderlich sind. Sie dienen als Add-Ons.
Regeln
- Eine Variable kann nicht als virtuell deklariert werden. Nur Eigenschaften, Methoden und Ereignisse können als virtuell deklariert werden.
- Ein statisches Mitglied kann nicht als virtuell deklariert werden.
- Ein abstraktes Mitglied kann nicht als virtuell deklariert werden.
- Ein privates Mitglied kann nicht als virtuell deklariert werden.
- Ein nicht virtuelles Mitglied kann nicht überschrieben werden.
- Die Zugriffsebene, der Typ und der Name der virtuellen Mitglieder und der übergeordneten Mitglieder müssen identisch sein. Wenn die virtuelle Methode beispielsweise öffentlich ist, muss auch die überschreibende Methode öffentlich sein.
Fazit - Virtuelles Schlüsselwort in C #
In diesem Artikel haben wir das Konzept der virtuellen in C # verstanden. Wir haben gesehen, wie C # das virtuelle Schlüsselwort zur Laufzeit implementiert, und haben uns die Beispiele angesehen.
Virtuelle Mitglieder sind ein großartiges Konzept der objektorientierten Programmierung. Es wird jedoch dringend empfohlen, sich mit abstrakten Schlüsselwörtern, Schnittstellen und neuen Schlüsselwörtern vertraut zu machen, um detaillierte Kenntnisse zu erlangen. Dies würde sehr helfen, den Unterschied zwischen ihnen allen zu verstehen. Dies hilft zu erkennen, wann und wann nicht virtuell zu verwenden ist.
Empfohlene Artikel
Dies ist eine Anleitung zum virtuellen Schlüsselwort in C #. Hier diskutieren wir, wie virtuell in C # funktioniert und wie der obige Code mit der mehrstufigen Vererbung und den Vorteilen zusammenarbeitet. Sie können auch den folgenden Artikel lesen, um mehr zu erfahren.
- Konstruktor in C # kopieren
- Vererbung in C #
- C # -Funktionen
- C # if-Anweisung
- If-Anweisung in Python
- Überladen in Java
- Python-Überladung
- Vererbung in PHP
- Vollständiger Leitfaden zur Vererbung in Python
- Arten von Konstruktoren in C # mit Code-Implementierung