Inleiding tot overbelasting en opheffing in C #
Polymorfisme is een van de belangrijke concepten in C #. Er zijn twee soorten polymorfisme, compileertijd en runtime. Overbelasting en Overriding concepten worden gebruikt om dit respectievelijk te bereiken. Bij het overschrijven kan een onderliggende klasse de methode van de bovenliggende klasse op een andere manier implementeren, maar de methode van de onderliggende klasse heeft dezelfde naam en dezelfde methodehandtekening als bovenliggende, terwijl bij overbelasting er meerdere methoden in een klasse zijn met dezelfde naam en verschillende parameters.
Hoe overschrijven en overladen werkt in C #?
De werking van opheffing en overbelasting in C # wordt hieronder met voorbeelden uitgelegd:
overschrijven
Er zijn enkele sleutelwoorden die we gebruiken bij het negeren, zoals virtueel, negeren en baseren.
Syntaxis:
class Parent
(
public virtual void Example() // base class
(
Console.WriteLine(“ parent class”);
)
)
class Child: Parent
(
public override void Example() // derived class
(
base.Example();
Console.WriteLine(“Child class”);
)
)
Hierin worden virtuele en vervangende sleutelwoorden gebruikt, wat betekent dat de basisklasse virtueel is en dat de onderliggende klasse deze klasse kan implementeren en overschrijven betekent dat deze onderliggende klasse dezelfde naam en dezelfde methodehandtekening heeft als de bovenliggende klasse.
Voorbeeld 1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverridingExample
(
class Subject // base class
(
public virtual void study() // base class method
(
Console.WriteLine("Study all the subjects");
)
)
class Mathematics: Subject // derived class
(
public override void study() // derived class method
(
Console.WriteLine("Study Mathematics");
)
)
class Program
(
// main method
static void Main(string() args)
(
Subject s = new Mathematics();
s.study();
Console.ReadLine();
)
)
)
In het bovenstaande voorbeeld is de naam van de methode hetzelfde, maar hun implementatie is anders. De basisklasse heeft virtueel en kan daarom de bovenliggende klassenmethode op zijn eigen manier implementeren. De child class-methode heeft trefwoord overschrijven, wat aangeeft dat deze methode een opheffingsmethode is.
Output:
Voorbeeld 2
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverridingExample
(
class Subject // base class
(
public virtual void study() // base class method
(
Console.WriteLine("Study all the subjects");
)
)
class Mathematics: Subject // derived class
(
public override void study() // derived class method
(
base.study();
Console.WriteLine("Study Mathematics");
)
)
class Program
(
// main method
static void Main(string() args)
(
Mathematics m = new Mathematics();
m.study();
Console.ReadLine();
)
)
)
Output:
In dit voorbeeld heeft de afgeleide klasse een basiszoekwoord dat wordt gebruikt om de basisklasse-methode aan te roepen. Dus in dat geval wordt de afgeleide methode genoemd naar de base class-methode.
Punten om te onthouden:
- In het overheersende concept is de naam van de methode en methodehandtekening en toegangsmodificator altijd hetzelfde als de bovenliggende en onderliggende klasse.
- De methode van de bovenliggende klasse kan niet statisch zijn.
overbelasting
Bij overbelasting zijn er meerdere methoden met verschillende methodesignatuur. Hieronder volgen enkele voorbeelden die laten zien hoe we overbelasting kunnen bereiken door het aantal parameters, de volgorde van parameters en gegevenstypen van parameters te variëren.
Voorbeeld 1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
(
class Demo
(
public int Sum(int x, int y)
(
int value = x + y;
return value;
)
public int Sum(int x, int y, int z)
(
int value = x + y + z;
return value;
)
public static void Main(string() args) // main method
(
Demo d = new Demo();
int sum1 = d.Sum(24, 28);
Console.WriteLine("sum of the two "
+ "integer value : " + sum1);
int sum2 = d.Sum(10, 20, 30);
Console.WriteLine("sum of the three "
+ "integer value : " + sum2);
Console.ReadLine();
)
)
)
In het bovenstaande voorbeeld zijn er twee methoden met dezelfde naam maar een ander aantal parameters. De eerste methode bestaat uit twee parameters, terwijl de tweede drie parameters heeft. Dit wordt methode-overbelasting genoemd.
Output:
Voorbeeld 2
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
(
class Demo
(
public int Sum(int x, int y, int z)
(
int value = x + y + z;
return value;
)
public double Sum(double x, double y, double z)
(
double value = x + y + z;
return value;
)
public static void Main(string() args) // main method
(
Demo d = new Demo();
int sum1 = d.Sum(24, 28, 7);
Console.WriteLine("sum of the two "
+ "integer value : " + sum1);
double sum2 = d.Sum(10.0, 20.0, 30.0);
Console.WriteLine("sum of the three "
+ "integer value : " + sum2);
Console.ReadLine();
)
)
)
In het bovenstaande voorbeeld zijn er twee methoden met dezelfde naam, maar hun gegevenstypen zijn verschillend. De eerste methode heeft een geheel gegevenstype, terwijl de tweede een dubbel gegevenstype heeft. Dus in dit geval variëren de parameters vanwege het verschillende datatype.
Output:
Voorbeeld # 3
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
(
class Demo
(
public void Details(String name, int id)
(
Console.WriteLine("Name " + name + ", "
+ "Id " + id); ;
)
public void Details(int id, string name)
(
Console.WriteLine("Name " + name + ", "
+ "Id " + id);
)
public static void Main(string() args) // main method
(
Demo d = new Demo();
d.Details("John", 10);
d.Details("Joe", 20);
Console.ReadLine();
)
)
)
In het bovenstaande voorbeeld is de naam van de methoden hetzelfde, maar de volgorde van parameters is anders. De eerste methode heeft een naam en ID resp. terwijl de tweede respectievelijk ID en naam heeft.
Output:
Punten om te onthouden:
- In een overbelastingsconcept is het niet mogelijk om meer dan één methode met dezelfde parameters te definiëren in geval van volgorde, type en nummer.
- Het is niet mogelijk om een methode te overbelasten op basis van de verschillende retourtypen.
Voordelen van overbelasting en opheffing in C #
- Overbelasting is een van de manieren om statische elektriciteit te bereiken en overriden is een van de manieren waarop C # dynamisch polymorfisme bereikt.
- Het biedt flexibiliteit voor de gebruiker en netheid van de code.
Conclusie
Overbelasting en opheffing spelen een belangrijke rol bij het bereiken van polymorfisme. Door opheffen kan afgeleide klasse op zijn eigen manier worden geïmplementeerd en anderzijds gaat overbelasting over methoden met dezelfde naam en verschillende soorten parameterimplementaties.
Aanbevolen artikelen
Dit is een gids voor overbelasting en opheffing in C #. Hier bespreken we de werking, syntaxis, voordelen van overbelasting en overschrijven in C # met voorbeelden en code-implementatie. U kunt ook de volgende artikelen bekijken voor meer informatie -
- Objecten in C #
- 2D-arrays in C #
- Overschrijven in C #
- Ruilen in C #
- Polymorfisme op Java
- 2D-afbeeldingen in Java
- 3 verschillende soorten arrays in PHP (voorbeelden)