Introduzione alla sostituzione in C #
La sostituzione in C # è la reimplementazione di un metodo di classe base in una classe derivata. In questo, il metodo della classe base viene sovrascritto nella classe figlio. Il metodo della classe derivata ha lo stesso nome e la stessa firma del metodo della classe base. L'override è utile per ottenere il polimorfismo di runtime.
Esistono alcune parole chiave utilizzate nella sostituzione del metodo.
1. Virtuale: questa parola chiave viene utilizzata con una classe base che indica che il metodo di una classe base può essere ignorato.
public virtual void Method()
(
// implementation
)
2. Sostituzione: questa parola chiave viene utilizzata con una classe derivata che indica che la classe derivata ha la precedenza su un metodo di una classe base.
public override void Method()
(
// implementation
)
3. Base: questa parola chiave viene utilizzata in una classe derivata per chiamare il metodo della classe base.
public override void Method()
(
base.Method();
// implementation
)
Come funziona l'override in C #?
Di seguito è riportato un esempio di come possiamo implementare l'override in C #.
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”);
)
)
Nell'esempio sopra ci sono due classi, una è la classe base o la classe genitore e l'altra è la classe derivata o possiamo dire, classe figlio. Un metodo di classe base è derivato in classe figlio. In questo, il metodo in un genitore è virtuale, il che significa che può essere sovrascritto dalla classe figlio. La sostituzione in un figlio significa che questo metodo è uguale al metodo della classe genitore con la stessa firma del metodo.
Tipi di sostituzione in C #
Di seguito sono riportati gli esempi che mostrano la sostituzione con varie parole chiave.
Esempio 1 - Senza parole chiave virtuali e di sostituzione
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();
)
)
)
Nell'esempio sopra, nessuna parola chiave viene utilizzata in entrambe le basi e nei metodi derivati.
Anche nel metodo principale, il riferimento parent viene utilizzato per chiamare il metodo child. Quindi, in questo caso, quando non viene utilizzata alcuna parola chiave, viene chiamato il metodo parent anziché un metodo child. Quindi l'output sarà
Produzione :
Esempio 2 (a) - Con parole chiave virtuali e override
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 questo esempio, virtuale viene utilizzato nella classe base, il che significa che autorizza la classe figlio a implementare il metodo a modo suo. In una classe derivata, viene utilizzata la sostituzione, il che significa che il metodo figlio è il metodo di sostituzione. Entrambi i metodi sono uguali con lo stesso nome e la stessa firma del metodo ma la parte di implementazione è diversa. Anche in questo esempio, il riferimento parent viene utilizzato per chiamare il metodo child. Ma come genitore è un metodo è virtuale, quindi il metodo figlio viene chiamato prima invece del metodo genitore. Quindi l'output sarà
Produzione :
Esempio 2 (b) - Parole chiave virtuali e di sostituzione
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();
)
)
)
Questo esempio è uguale all'esempio precedente ma questo metodo figlio viene utilizzato come riferimento.
Produzione :
Esempio 3 - Con parola chiave di base
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();
)
)
)
Nell'esempio sopra, la base viene utilizzata in una classe derivata per chiamare il metodo della classe base. Quindi in questo metodo di base viene chiamato prima e poi il metodo derivato.
Produzione :
Esempio 4 - Classi astratte con sostituzione
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();
)
)
)
Nell'esempio sopra, viene utilizzato un metodo astratto. Una classe astratta è implementata dalla classe derivata che contiene un metodo astratto.
Produzione :
Regole per l'override del metodo
- La firma del metodo di una classe derivata dovrebbe essere la stessa di una classe base.
- La sostituzione non è possibile nella stessa classe.
- I modificatori di accesso devono essere gli stessi per i metodi virtuali e i metodi di sostituzione.
- La parola chiave virtuale viene utilizzata nel metodo della classe di base e la sostituzione viene utilizzata in un metodo della classe derivata.
- Il metodo della classe base non dovrebbe essere statico.
Conclusione
L'override è utile nel polimorfismo di runtime. Consente alla classe derivata di implementare un metodo di classe base a modo suo. Quindi l'implementazione del metodo è diversa dalla classe derivata dalla sua classe base. Il metodo override può essere virtuale, override o astratto.
Articoli consigliati
Questa è una guida per eseguire l'override in C #. Qui discutiamo come usare l'override e le diverse parole chiave per l'override in C # insieme agli esempi. Puoi anche consultare i nostri altri articoli suggeriti:
- Gestione delle eccezioni in C #
- Matrici in C #
- Sostituzione del metodo in C #
- Variabili in C #
- Modificatori di accesso in PHP
- Polimorfismo in Java
- Classi astratte in JavaScript
- Esempi di questa parola chiave