Inleiding tot virtueel trefwoord in C #
Wat is het virtuele trefwoord? Voordat we meteen in C # -perspectief springen, is het belangrijk om het concept van overerving, dwingend en virtueel trefwoord in de objectgeoriënteerde programmeerwereld te begrijpen of te herzien.
Methode Overriding is een OOPs-concept dat nauw verbonden is met Overerving. Wanneer een methode van de onderliggende klasse de methode van de bovenliggende klasse met dezelfde naam, dezelfde parameters en hetzelfde retourtype overschrijft, wordt deze methode als vervangende methode genoemd. Een virtueel trefwoord is een indicatie voor de compiler dat een methode kan worden genegeerd in afgeleide klassen.
Vanuit het C # -perspectief wordt het virtuele sleutelwoord gebruikt om de declaratie van een eigenschap, methode of gebeurtenis aan te passen om overschrijven in een afgeleide klasse toe te staan. In eenvoudige bewoordingen, implementeert het virtuele sleutelwoord het methode-overschrijvende concept in C #.
Syntaxis
Elke eigenschap, methode of gebeurtenis kan worden opgeheven door het virtuele trefwoord in de basisklasse toe te voegen en het trefwoord in de afgeleide klasse te overschrijven.
Voeg het virtuele trefwoord toe aan de aangifte basisklasse:
public class Base (
public virtual int abc ( get; set; ) // this property can be overridden
public virtual void Xyz() ( ) // this method can be overridden
)
Voeg het override-sleutelwoord toe aan de basisklasse-aangifte:
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
)
Hoe virtueel werkt in C #?
Het zeer fundamentele verschil tussen overbelasting en opheffing is dat het eerste een compilatie-mechanisme is, terwijl het tweede tijdens de uitvoering in het spel komt. Een virtueel trefwoord komt tijdens runtime in actie en implementeert daarmee het concept van de methode met voorrang.
Wanneer een virtuele methode of eigenschap wordt aangeroepen of geopend, controleert de compiler of er een overheersend lid van de methode of de eigenschap is. Als er een wordt gevonden, wordt deze ingeroepen. Als er geen wordt gevonden, wordt de oorspronkelijke methode of eigenschap aangeroepen.
Een uitstekende vraag rijst hier - wat gebeurt er in het geval van overerving op meerdere niveaus? Welnu, als een lid van de klasse in meer dan één niveau wordt overschreven, wordt het diepste overschreven lid aangeroepen (het lid in de meest afgeleide klasse).
Voorbeeld
Het volgende voorbeeld van virtueel trefwoord in C # wordt hieronder genoemd
Overerving op één niveau
Laten we een voorbeeld nemen om de werking van een virtueel trefwoord te begrijpen wanneer een enkele onderliggende klasse de bovenliggende klasse erft, dat wil zeggen dat er geen overerving op meerdere niveaus is.
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());
)
)
Hoe werkt de bovenstaande code?
In de basisklasse Polynomial hebben we twee eigenschappen en één methode als virtueel verklaard. Deze kunnen nu worden opgeheven in kindklassen. Nu maken we verschillende kindklassen van verschillende vormen die de Polynomiale klasse erven.
In de klasse Rectangle hoeven we geen enkele eigenschap of methode te overschrijven. De implementatie van de basisklasse zou werken zoals deze is voor de klasse Rectangle.
In de klasse Square hebben we niet de eigenschap width. Dus overschrijven we de eigenschap length en de methode Area om het kwadraat van de lengte terug te geven.
In de klasse Circle hebben we geen lengte of breedte. Dus verklaren we een nieuwe klasse-specifieke eigenschap van straal en overschrijven de methode Area dienovereenkomstig.
In de klasse Driehoek overschrijven we eenvoudig de methode Gebied en de eigenschappen worden overgenomen van de basisklasse Polynomiaal.
Wanneer we objecten van de afgeleide klassen maken, ontmoet de compiler het virtuele trefwoord tijdens de constructie van de basisklasse en zoekt dus naar de overschreven leden. De opgeheven leden worden dan dienovereenkomstig ingeroepen.
Overname op meerdere niveaus
Laten we het bovenstaande voorbeeld wijzigen om overerving op meerdere niveaus op te nemen.
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());
)
)
voordelen
Een virtueel lid heeft verklaringen en definities in zowel de basisklasse als afgeleide klassen. Virtuele leden zijn voordelig wanneer sommige extra functionaliteiten vereist zijn in de afgeleide klassen. Ze dienen als add-ons.
Reglement
- Een variabele kan niet virtueel worden verklaard. Alleen eigenschappen, methoden en gebeurtenissen kunnen als virtueel worden verklaard.
- Een statisch lid kan niet virtueel worden verklaard.
- Een abstract lid kan niet virtueel worden verklaard.
- Een privélid kan niet virtueel worden verklaard.
- Een niet-virtueel lid kan niet worden opgeheven.
- Het toegangsniveau, het type en de naam van beide virtuele leden en de overheersende leden moeten hetzelfde zijn. Als de virtuele methode bijvoorbeeld openbaar is, moet de dwingende methode ook openbaar zijn.
Conclusie - virtueel trefwoord in C #
In dit artikel begrepen we het concept van virtueel in C #. We zagen hoe C # het virtuele trefwoord implementeerde tijdens runtime en keken naar de voorbeelden.
Virtuele leden zijn een geweldig concept van objectgeoriënteerd programmeren. Voor diepgaande kennis wordt het echter ten zeerste aanbevolen om meer te weten te komen over abstract trefwoord, interfaces en nieuw trefwoord. Dit zou enorm helpen om het verschil tussen hen allemaal te begrijpen. Dit helpt bij het realiseren wanneer en wanneer niet virtueel te gebruiken.
Aanbevolen artikelen
Dit is een gids voor virtueel trefwoord in C #. Hier bespreken we hoe Virtual in C # werkt en hoe de bovenstaande code werkt met de multi-level overerving en voordelen. U kunt ook het volgende artikel bekijken voor meer informatie-
- Kopieer Constructor in C #
- Overerving in C #
- C # Functies
- C # als Verklaring
- If Statement in Python
- Overbelasting in Java
- Python overbelast
- Overerving in PHP
- Volledige gids voor erfenis in Python
- Soorten constructor in C # met code-implementatie