Polymorphismus ist ein Konzept, das in objektorientierten Programmiersprachen wie C# umgesetzt wird, bei denen ein Operator oder eine funktionale Methode während des Ausführungsprozesses mehr als eine Form annehmen kann. Es wird häufig für die Implementierung der Vererbung im Programm verwendet und wird in zwei Methoden eingeteilt, nämlich Operatorüberladung und Funktionsüberladung. Mit einfachen Worten kann Polymorphismus als eine Technik zum Ändern der Basisklasse mithilfe der abgeleiteten Klasse erklärt werden, wobei beide Klassen unterschiedliche Eigenschaften besitzen.
Das folgende Diagramm veranschaulicht die Funktionsweise des Polymorphismus:
Diese Abbildung erklärt, dass Ton das Ausgangsobjekt ist, aus dem Töpfe, Schüsseln und Spielzeugobjekte hergestellt werden. Alle diese Objekte unterscheiden sich voneinander, haben jedoch die Eigenschaften von Ton. Diese drei Objekte haben unterschiedliche Formen und werden auf unterschiedliche Weise verwendet, auch wenn sie aus demselben Material, Ton, hergestellt sind.
Im Folgenden sind die 2 Formen des Polymorphismus aufgeführt:
Ein Operator kann basierend auf der Art der Operanden, mit denen er arbeitet, unterschiedliche Ausgaben ausgeben. Dies wird als Operatorüberladung bezeichnet. Beispielsweise kann der Operator „+“ eine Addition für zwei ganze Zahlen durchführen, während er zwei Zeichenfolgen verketten kann. Somit kann derselbe Operator auf zwei verschiedene Arten verwendet werden. Der Additionsoperator addiert im Allgemeinen zwei Zahlen. Bei komplexen Zahlen ist die Addition jedoch etwas anders, da hier die entsprechenden Realteile und Imaginärteile separat addiert werden. Hier ist ein Beispielcode, der zeigt, wie der Operator „+“ überladen werden kann, um komplexe Zahlen hinzuzufügen.
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();
}
}
}Ausgabe:
Diese Ausgabe veranschaulicht die Operatorüberladung zum Addieren zweier komplexer Zahlen. Der Code zeigt sowohl eine Operatorüberladung als auch eine Funktionsüberladung.
Eine Funktion kann je nach Anzahl der Parameter sowie deren Rückgabetypen und dem Rückgabetyp der Funktion unterschiedliche Ausgaben liefern. Der oben genannte Code behandelt auch das Überladen von Funktionen mithilfe eines Konstruktors. Der Code enthält zwei Konstruktoren. Einer ist der Standardkonstruktor, der leer bleibt, während der andere ein parametrisierter Konstruktor ist, der verwendet wird, um die komplexe Zahl mit den als Parameter genannten Werten zu initialisieren.
Bei dem in der Abbildung dargestellten Beispiel besteht die Funktion darin, den Ton zu formen, und die Strichrichtung ist das Element, das zum Formen des Tons vorgesehen ist. Durch unterschiedliche Strichrichtungen wird Ton in einen Topf, eine Schüssel bzw. ein Spielzeug verwandelt.
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<Clay>
{
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();
}
}
}Ausgabe:
Wie Sie vielleicht im Code bemerkt haben, ist die Tonklasse die übergeordnete Klasse, deren untergeordnete Klassen Topf-, Spielzeug- und Schüsselklassen sind. Die Methode „Mould“ ist sowohl in der übergeordneten Klasse als auch in der untergeordneten Klasse mit derselben Funktionssignatur definiert. Wenn also ein Objekt der untergeordneten Klasse erstellt wird und die Methode Mould aufruft, wird die Methode der Basisklasse durch die Methode der untergeordneten Klasse überschrieben. Somit sehen wir die Ausgabe der Methode der untergeordneten Klasse. Der obige Code zeigt das Überschreiben und nicht das Überladen von Methoden, um den Polymorphismus zu veranschaulichen.
Die Punkte, die bei Polymorphismus in C# zu beachten sind:
Im Folgenden sind die wichtigsten Erkenntnisse aufgeführt:
Das obige ist der detaillierte Inhalt vonPolymorphismus in C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
