Inleiding tot negeren in C #
Overschrijven in C # is de herimplementatie van een basisklasse-methode in een afgeleide klasse. Hierin wordt de basisklasse-methode overschreven in de kindklasse. De afgeleide klasse-methode heeft dezelfde naam en handtekening als de base class-methode. Overschrijven is nuttig bij het bereiken van Runtime-polymorfisme.
Er zijn een paar sleutelwoorden die worden gebruikt bij het overschrijven van de methode.
1. Virtueel - Dit trefwoord wordt gebruikt met een basisklasse die aangeeft dat de methode van een basisklasse kan worden opgeheven.
public virtual void Method()
(
// implementation
)
2. Overschrijven - Dit trefwoord wordt gebruikt met een afgeleide klasse die aangeeft dat die afgeleide klasse een methode van een basisklasse overschrijft.
public override void Method()
(
// implementation
)
3. Base - Dit trefwoord wordt in een afgeleide klasse gebruikt om de base class-methode aan te roepen.
public override void Method()
(
base.Method();
// implementation
)
Hoe werkt Overriding in C #?
Hieronder ziet u een voorbeeld van hoe we het negeren in C # kunnen implementeren.
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”);
)
)
In het bovenstaande voorbeeld zijn er twee klassen, één is basisklasse of bovenliggende klasse en de andere is afgeleide klasse of we kunnen zeggen, kindklasse. Een base class-methode wordt afgeleid in child class. Hierin is de methode in een ouder virtueel, wat betekent dat deze door de onderliggende klasse kan worden opgeheven. Overschrijven bij een kind betekent dat deze methode hetzelfde is als de methode van de bovenliggende klasse met dezelfde methodehandtekening.
Soorten overschrijven in C #
Hieronder staan de voorbeelden die laten zien dat er voor verschillende trefwoorden moet worden genegeerd.
Voorbeeld 1 - Zonder virtuele en vervangende zoekwoorden
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();
)
)
)
In het bovenstaande voorbeeld wordt geen sleutelwoord gebruikt in zowel basen als afgeleide methoden.
Ook wordt in de hoofdmethode de ouderreferentie gebruikt om de onderliggende methode aan te roepen. Dus als in dit geval geen trefwoord wordt gebruikt, wordt de bovenliggende methode aangeroepen in plaats van een onderliggende methode. Dus de output zal zijn
Uitgang:
Voorbeeld 2 (a) - Met virtuele en vervangende zoekwoorden
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 dit voorbeeld wordt virtueel gebruikt in de basisklasse, wat betekent dat het de onderliggende klasse machtigt om de methode op zijn eigen manier te implementeren. In een afgeleide klasse wordt override gebruikt, wat betekent dat de onderliggende methode de override-methode is. Beide methoden zijn hetzelfde met dezelfde naam en dezelfde methodehandtekening, maar het implementatiegedeelte is anders. In dit voorbeeld wordt ook de ouderreferentie gebruikt om de onderliggende methode aan te roepen. Maar omdat een ouder een methode is, is deze virtueel, dus wordt de onderliggende methode eerst aangeroepen in plaats van de bovenliggende methode. Dus de output zal zijn
Uitgang:
Voorbeeld 2 (b) - Virtuele en vervangende zoekwoorden
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();
)
)
)
Dit voorbeeld is hetzelfde als het vorige voorbeeld, maar deze onderliggende methode wordt als referentie gebruikt.
Uitgang:
Voorbeeld 3 - Met basiszoekwoord
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();
)
)
)
In het bovenstaande voorbeeld wordt de base gebruikt in een afgeleide klasse om de base class-methode aan te roepen. Dus in deze basismethode wordt eerst de methode en vervolgens de afgeleide methode genoemd.
Uitgang:
Voorbeeld 4 - Abstracte klassen met overschrijven
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();
)
)
)
In het bovenstaande voorbeeld wordt een abstracte methode gebruikt. Een abstracte klasse wordt geïmplementeerd door de afgeleide klasse die een abstracte methode bevat.
Uitgang:
Regels voor het negeren van methoden
- De methodehandtekening van een afgeleide klasse moet hetzelfde zijn als een basisklasse.
- Overschrijven is niet mogelijk in dezelfde klasse.
- Toegangsmodificeerders moeten hetzelfde zijn voor virtuele methoden en vervangingsmethoden.
- Het virtuele sleutelwoord wordt gebruikt in de basisklasse-methode en Override wordt gebruikt in een afgeleide klasse-methode.
- De base class-methode mag niet statisch zijn.
Conclusie
Overschrijven is nuttig bij runtime-polymorfisme. Hiermee kan afgeleide klasse op zijn eigen manier een base class-methode implementeren. Dus de methode-implementatie verschilt van de afgeleide klasse van de basisklasse. De overschreven methode kan virtueel, overschrijven of abstract zijn.
Aanbevolen artikelen
Dit is een gids voor opheffen in C #. Hier bespreken we hoe u vervangende en verschillende trefwoorden voor het negeren in C # kunt gebruiken, samen met voorbeelden. U kunt ook onze andere voorgestelde artikelen doornemen -
- Uitzonderingsafhandeling in C #
- Arrays in C #
- Methode overschrijven in C #
- Variabelen in C #
- Toegang tot modificaties in PHP
- Polymorfisme op Java
- Abstracte klassen in JavaScript
- Voorbeelden van dit trefwoord