Einführung in den Polymorphismus in C #
Polymorphismus ist eines der Prinzipien der objektorientierten Programmierung. Poly bedeutet multiple und Morphing bedeutet eine Transformation, Polymorphismus bedeutet somit die Fähigkeit, multiple Formen anzunehmen.
Die Ausgabe der Operatoren hängt von den Typen der Operanden ab. Dies ist eine Form des Polymorphismus, die als Operatorüberladung bezeichnet wird. Hier kann der Bediener mehrere Formen annehmen, um verschiedene Ausgaben zu erzeugen. Die Ausgabe der Funktionen hängt von verschiedenen Rückgabetypen und Parametern ab. Dies ist eine andere Form des Polymorphismus, die als Funktionsüberladung bezeichnet wird. Hier nimmt die Funktion mehrere Formen an, um mehrere Ausgaben zu erzeugen.
Polymorphismus wird häufig zur Implementierung der Vererbung verwendet. Objekte mit unterschiedlicher interner Struktur können durch Polymorphismus eine gemeinsame Schnittstelle implementieren. Das folgende Diagramm zeigt die Funktionsweise des Polymorphismus:
Diese Abbildung erklärt, dass Ton das übergeordnete Objekt ist, aus dem Topf-, Schüssel- und Spielzeugobjekte hergestellt werden. Alle diese Objekte unterscheiden sich voneinander, haben aber die Eigenschaften von Ton. Diese drei Objekte haben unterschiedliche Formen und werden auf unterschiedliche Weise verwendet, auch wenn sie aus dem gleichen Material Ton bestehen.
Formen des Polymorphismus
Nachfolgend sind die 2 Formen des Polymorphismus aufgeführt:
1. Überladen des Bedieners
Ein Operator kann abhängig von der Art der Operanden, mit denen er arbeitet, unterschiedliche Ausgaben geben. Dies wird als Operatorüberladung bezeichnet. Beispielsweise kann der Operator '+' das Addieren von zwei Ganzzahlen ausfü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 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 das Überladen von Operatoren, um zwei komplexe Zahlen hinzuzufügen. Der Code zeigt das Überladen von Bedienern sowie das Überladen von Funktionen.
2. Funktionsüberladung
Eine Funktion kann abhängig von der Anzahl der Parameter sowie deren Rückgabetypen und dem Funktionsrückgabetyp unterschiedliche Ausgaben liefern. Der oben genannte Code behandelt auch das Überladen von Funktionen mit einem Konstruktor. Der Code enthält 2 Konstruktoren. Einer ist der Standardkonstruktor, der leer bleibt, während der andere ein parametrisierter Konstruktor ist, mit dem die komplexe Zahl mit den als Parameter angegebenen Werten initialisiert wird.
In dem in der Figur dargestellten Beispiel ist die Funktion das Formen des Tons und die Hubrichtung das Element, das zum Formen des Tons vorgesehen ist. Ausgehend von verschiedenen Schlagrichtungen wird Ton in Topf, Schüssel und 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
(
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 Elternklasse, deren Kindklassen Topf-, Spielzeug- und Schüsselklassen sind. Die Methode 'Mold' ist sowohl in der Elternklasse als auch in der Kindklasse mit der gleichen Funktionssignatur definiert. Wenn also ein Objekt der untergeordneten Klasse erstellt wird und die Methode Mold aufgerufen wird, wird die Basisklassenmethode von der untergeordneten Klassenmethode überschrieben. Somit sehen wir die Ausgabe der Kindklassenmethode. Der obige Code zeigt, wie Methoden überschrieben und nicht überladen werden, um den Polymorphismus zu veranschaulichen.
Zu beachtende Punkte für den Polymorphismus in c #
- Überladen unterscheidet sich von Überschreiben. Das Überladen hat unterschiedliche Funktionssignaturen, während das Überschreiben dieselben Funktionssignaturen hat
- Polymorphismus bezieht sich auf das Ändern des Verhaltens einer Oberklasse in der Unterklasse.
- Vererbung bezieht sich auf die Verwendung der Struktur und des Verhaltens einer Oberklasse in einer Unterklasse.
Im Folgenden sind die wenigen wichtigen Imbissbuden aufgeführt:
- Der Polymorphismus ist eines der wichtigsten Paradigmen der objektorientierten Programmierung.
- Durch das Überladen von Funktionen wird die Funktion gemäß den Rückgabetypen und Parametern der Funktion in der geerbten Klasse geändert.
- Durch das Überladen von Operatoren wird die Operatordefinition gemäß den angegebenen Parametern geändert.
- Mit Polymorphismus wird implementiert, dass zur Laufzeit entschieden wird, die untergeordnete Klassenmethode mithilfe von Methodenüberschreibung aufzurufen.
Empfohlene Artikel
Dies ist eine Anleitung zum Polymorphismus in C #. Hier diskutieren wir die beiden Formen des Polymorphismus in C #, dh das Überladen von Operatoren und das Überladen von Funktionen mit Beispielcode. Sie können auch den folgenden Artikel lesen, um mehr zu erfahren -
- Was ist StringBuilder in C #
- Konstruktor in C # kopieren
- Was ist Multithreading in C #?
- Was ist ein Entwurfsmuster in C #?
- Arten von Konstruktoren in C # mit Code-Implementierung
- Vollständige Anleitung zum Multithreading in C #