Inleiding tot polymorfisme in C #
Polymorfisme is een van de principes van objectgericht programmeren. Poly betekent meervoudig en morphing betekent een transformatie ondergaan, polymorfisme betekent dus het vermogen om meerdere vormen aan te nemen.
De output van de operatoren varieert afhankelijk van het type operanden, wat een vorm van polymorfisme is die bekend staat als Operator-overbelasting. Hier kan de operator meerdere vormen aannemen om verschillende uitgangen te produceren. De uitvoer van de functies varieert op basis van verschillende retourtypen en parameters, een andere vorm van polymorfisme die bekend staat als Functie-overbelasting. Hier neemt de functie meerdere vormen aan om meerdere uitgangen te produceren.
Polymorfisme wordt veelvuldig gebruikt om overerving te implementeren. Objecten met een verschillende interne structuur kunnen via polymorfisme een gemeenschappelijke interface implementeren. Het volgende diagram illustreert de werking van polymorfisme:
Deze figuur legt uit dat klei het ouderobject is waaruit pot-, kom- en speelgoedobjecten worden gemaakt. Al deze objecten zijn verschillend van elkaar, maar ze hebben de eigenschappen van klei. Deze drie objecten hebben verschillende vormen en worden op verschillende manieren gebruikt, zelfs wanneer ze gemaakt zijn van dezelfde materiële klei.
Vormen van polymorfisme
Hieronder staan de 2 vormen van polymorfisme:
1. Overbelasting van de operator
Een operator kan verschillende uitgangen geven op basis van het type operanden waarop hij werkt. Dit wordt operatoroverbelasting genoemd. Bijvoorbeeld, de operator '+' kan optellen op twee gehele getallen, terwijl het twee strings kan samenvoegen. Zo kan dezelfde operator op 2 verschillende manieren worden gebruikt. De opteloperator voegt meestal twee nummers toe. In het geval van complexe getallen is de toevoeging echter een beetje anders, waarbij de bijbehorende reële delen en denkbeeldige delen afzonderlijk worden toegevoegd. Hier is een voorbeeldcode die laat zien hoe de operator '+' kan worden overbelast om complexe getallen toe te voegen:
Code:
using System;
namespace Overload (
class Complex
(
public double x;
public double y;
// no-argument constructor
public Complex() ()
// parameterized constructor
public Complex(double real, double img)
(
x = real;
y = img;
)
// Overloading of Binary "+" operator
public static Complex operator + (Complex c1,
Complex c2)
(
Complex c3 = new Complex();
c3.x = c1.x + c2.x;
c3.y = c1.y + c2.y;
return c3;
)
// function to display result
public void display()
(
Console.WriteLine("(0) + (1)i", x, y);
)
)
class CalNum (
// Driver Code
static void Main(string() args)
(
Complex num1 = new Complex(2.5, 3.5);
Complex num2 = new Complex(1.2, 6.5);
Complex num3 = num1 + num2;
Console.Write("c1 = ");
num1.display();
Console.Write("c2 = ");
num2.display();
Console.Write("c3 = ");
num3.display();
)
)
)
Output:
Deze uitvoer illustreert overbelasting van de operator om twee complexe getallen toe te voegen. De code toont overbelasting van de operator en overbelasting van de functie.
2. Functie overbelast
Een functie kan verschillende uitgangen geven op basis van het aantal parameters, hun retourtypen en het functie-retourtype. De bovengenoemde code dekt ook functieoverbelasting met behulp van een constructor. Er zijn 2 constructors in de code; de ene is de standaardconstructor die leeg blijft, terwijl de andere een geparametriseerde constructor is die wordt gebruikt om het complexe getal te initialiseren met de waarden die als parameters worden vermeld.
Aan de hand van het in de figuur geïllustreerde voorbeeld is de functie het vormen van de klei en is de slagrichting het element dat wordt verschaft om de klei te vormen. Gebaseerd op verschillende slagrichtingen, wordt klei getransformeerd in respectievelijk de pot, kom en speelgoed.
Code:
using System;
using System.Collections.Generic;
public class Clay
(
// A few example members
public int Height ( get; set; )
public int strokeDirection ( get; set; )
// Virtual method
public virtual void Mould()
(
Console.WriteLine("Beginning to mould the clay");
)
)
class Pot : Clay
(
public override void Mould()
(
// Code to make a pot Console.WriteLine("Making a pot");
base.Mould();
)
)
class Bowl : Clay
(
public override void Mould()
(
// Code to make a bowl
Console.WriteLine("Making a bowl");
base.Mould();
)
)
class Toy : Clay
(
public override void Mould()
(
// Code to make a toy
Console.WriteLine("Making a toy");
base.Mould();
)
)
class Program
(
static void Main(string() args)
(
// Illustrating Polymorphism #1: a Pot, Bowl and Toy
// can all be used wherever Clay is expected. No cast is
// needed because an implicit conversion exists from a derived
// class to its base class.
var items = new List
(
new Pot(),
new Bowl(),
new Toy()
);
// Polymorphism at work #2: the virtual method Mould is
// invoked on each of the derived classes, not the base class.
foreach (var item in items)
(
item.Mould();
)
)
)
Output:
Zoals je misschien in de code hebt opgemerkt, is kleiklasse de ouderklasse waarvan de kindklassen pot-, speelgoed- en komklassen zijn. De methode 'Mold' wordt gedefinieerd in de bovenliggende klasse en in de onderliggende klasse met dezelfde functiesignatuur. Wanneer een object van de child-klasse wordt gemaakt en het de methode Mold aanroept, wordt de base class-methode dus overschreven door de child class-methode. We zien dus de output van de child class-methode. De bovenstaande code toont de methode die de override en niet de overbelasting gebruikt om polymorfisme te illustreren.
Aandachtspunten voor polymorfisme in c #
- Overbelasting verschilt van Overriding. Overbelasting heeft verschillende functiehandtekeningen, terwijl overschrijven dezelfde functiehandtekeningen heeft
- Polymorfisme verwijst naar het veranderen van het gedrag van een superklasse in de subklasse.
- Overerving verwijst naar het gebruik van de structuur en het gedrag van een superklasse in een subklasse.
Hier volgen enkele belangrijke afhaalrestaurants:
- Polymorfisme is een van de belangrijkste paradigma's van objectgeoriënteerd programmeren.
- Functieoverbelasting wijzigt de functie volgens de retourtypen en parameters van de functie in de overgenomen klasse.
- Overbelasting van de operator wijzigt de definitie van de operator volgens de gegeven parameters.
- Polymorfisme wordt gebruikt om te implementeren en besluit tijdens runtime om de child class-methode aan te roepen met behulp van de methode override.
Aanbevolen artikelen
Dit is een gids voor polymorfisme in C #. Hier bespreken we de twee vormen van polymorfisme in C # dwz operatoroverbelasting en functieoverbelasting met voorbeeldcode. U kunt ook het volgende artikel bekijken voor meer informatie -
- Wat is StringBuilder in C #
- Kopieer Constructor in C #
- Wat is multithreading in C #?
- Wat is ontwerppatroon in C #?
- Soorten constructor in C # met code-implementatie
- Volledige gids voor multithreading in C #