Introduzione alla parola chiave virtuale in C #
Qual è la parola chiave virtuale? Prima di passare direttamente alla prospettiva C #, è importante comprendere o rivedere il concetto di eredità, sostituzione e parola chiave virtuale nel mondo della programmazione orientata agli oggetti.
Il metodo Overriding è un concetto di OOP strettamente legato all'ereditarietà. Quando un metodo di classe figlio sostituisce il metodo di classe padre con lo stesso nome, parametri e tipo restituito, viene definito come metodo di sostituzione. Una parola chiave virtuale indica al compilatore che un metodo può essere sovrascritto nelle classi derivate.
Venendo alla prospettiva C #, la parola chiave virtuale viene utilizzata per modificare la dichiarazione di qualsiasi proprietà, metodo o evento per consentire l'override in una classe derivata. In parole povere, la parola chiave virtuale implementa il metodo che sostituisce il concetto in C #.
Sintassi
Qualsiasi proprietà, metodo o evento può essere sovrascritto aggiungendo la parola chiave virtuale nella classe base e sovrascrivendo la parola chiave nella classe derivata.
Aggiungi la parola chiave virtuale nella dichiarazione della classe base:
public class Base (
public virtual int abc ( get; set; ) // this property can be overridden
public virtual void Xyz() ( ) // this method can be overridden
)
Aggiungi la parola chiave override nella dichiarazione della classe base:
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
)
Come funziona virtuale in C #?
La differenza fondamentale tra sovraccarico e override è che il primo è un meccanismo di compilazione, mentre il secondo entra in gioco in fase di esecuzione. Una parola chiave virtuale entra in azione in fase di esecuzione, implementando così il concetto di sostituzione del metodo.
Quando viene richiamato o eseguito l'accesso a qualsiasi metodo o proprietà virtuale, il compilatore verifica la presenza di un membro prioritario del metodo o della proprietà. Se ne viene trovato uno, viene invocato. Se non viene trovato nessuno, viene invocato il metodo o la proprietà originale.
Qui sorge un'eccellente domanda: cosa succede nel caso dell'eredità multilivello? Bene, se un membro della classe viene ignorato in più di un livello, viene invocato il membro scavalcato più profondo (quello nella classe più derivata).
Esempio
Il seguente esempio di parola chiave virtuale in C # è menzionato di seguito
Ereditarietà a livello singolo
Facciamo un esempio per comprendere il funzionamento di una parola chiave virtuale quando una singola classe figlio eredita la classe genitore, ovvero non esiste un'eredità multilivello.
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());
)
)
Come funziona il codice precedente?
Nella classe base Polynomial, abbiamo dichiarato due proprietà e un metodo come virtuali. Questi possono ora essere ignorati nelle classi secondarie. Ora creiamo varie classi figlio di forme diverse ereditando la classe Polinomiale.
Nella classe Rectangle, non è necessario sovrascrivere alcuna proprietà o metodo. L'implementazione della classe base funzionerebbe così com'è per la classe Rectangle.
Nella classe Square, non abbiamo la proprietà width. Quindi sovrascriviamo la proprietà length e il metodo Area per restituire il quadrato della lunghezza.
Nella classe Circle, non abbiamo né lunghezza né larghezza. Pertanto, dichiariamo una nuova proprietà specifica di classe del raggio e sovrascriviamo il metodo Area di conseguenza.
Nella classe Triangle, abbiamo semplicemente l'override del metodo Area e le proprietà sono ereditate dalla classe base Polynomial.
Quando creiamo oggetti delle classi derivate, il compilatore incontra la parola chiave virtuale durante la costruzione della classe base e quindi cerca i membri sovrascritti. I membri sostituiti vengono quindi richiamati di conseguenza.
Ereditarietà multilivello
Modifichiamo l'esempio sopra per includere l'ereditarietà multilivello.
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());
)
)
vantaggi
Un membro virtuale ha dichiarazioni e definizioni sia nella classe base che nelle classi derivate. I membri virtuali sono vantaggiosi quando sono richieste alcune funzionalità extra nelle classi derivate. Servono come componenti aggiuntivi.
Regole
- Una variabile non può essere dichiarata virtuale. Solo le proprietà, i metodi e gli eventi possono essere dichiarati come virtuali.
- Un membro statico non può essere dichiarato virtuale.
- Un membro astratto non può essere dichiarato virtuale.
- Un membro privato non può essere dichiarato virtuale.
- Un membro non virtuale non può essere sovrascritto.
- Il livello di accesso, il tipo e il nome di entrambi i membri virtuali e dei membri prioritari devono essere gli stessi. Ad esempio, se il metodo virtuale è pubblico, anche il metodo di sostituzione deve essere pubblico.
Conclusione - Parola chiave virtuale in C #
In questo articolo, abbiamo capito il concetto di virtuale in C #. Abbiamo visto come C # implementa la parola chiave virtuale durante il runtime e abbiamo esaminato gli esempi.
I membri virtuali sono un ottimo concetto di programmazione orientata agli oggetti. Tuttavia, per acquisire conoscenze approfondite, si consiglia vivamente di conoscere parole chiave astratte, interfacce e nuove parole chiave. Ciò aiuterebbe molto a comprendere la differenza tra tutti. Questo aiuta a capire quando usare e quando non usare virtuale.
Articoli consigliati
Questa è una guida alla parola chiave virtuale in C #. Qui discutiamo di come funziona virtuale in C # e come funziona il codice sopra con l'ereditarietà e i vantaggi multilivello. Puoi anche leggere il seguente articolo per saperne di più-
- Copia costruttore in C #
- Eredità in C #
- Funzioni C #
- Dichiarazione C # if
- Dichiarazione If in Python
- Sovraccarico in Java
- Sovraccarico di Python
- Eredità in PHP
- Guida completa all'ereditarietà in Python
- Tipi di costruttore in C # con implementazione del codice