Übersicht zum Überladen in C #
Beim Überladen in C # ist Polymorphismus ein Konzept der objektorientierten Programmierung, das die Fähigkeit eines Objekts, einer Variablen oder einer Methode definiert, während der Kompilierung / Laufzeit mehrere Formen anzunehmen. Die Echtzeitfaktoren wie Daten, Parameter, Rückgabe eines Objekts usw. bestimmen, in welcher Form das Objekt / die Methode / die Variable vorliegen soll. Auf diese Weise kann der Programmierer generischer als spezifischer codieren. ZB isst du Obst. Wie Sie Früchte essen, hängt davon ab, welche Früchte Ihnen in Echtzeit zur Verfügung gestellt werden. Sie essen sofort einen Apfel, während Sie vor dem Essen eine Banane schälen. Einfach.
Was ist das Überladen von Methoden in C #?
Method Overloading ist die kompilierte Implementierung des Konzepts des Polymorphismus. Entwickler können ähnliche Methoden mit demselben Namen definieren, wobei sich die Anzahl der Argumente, die Reihenfolge der Argumente oder die Art der Argumente unterscheiden. Im Beispiel Obst müssen Sie nicht für jede Frucht eigene Methoden definieren (eatApple, eat the banana, etc.). Sie können den gleichen Namen verwenden, um Obst zu essen und ihm verschiedene Parameter zu übergeben. Der Compiler würde automatisch die entsprechende Methode aufrufen.
Nehmen wir jetzt die Perspektive von C # ein. Einfach ausgedrückt bedeutet das Überladen von Methoden in C #, dass Sie über zwei oder mehr Methoden mit demselben Namen, aber unterschiedlichen Signaturen verfügen. Dies kann auf verschiedene Arten erreicht werden:
- Die unterschiedliche Anzahl von Parametern.
- Verschiedene Arten von Parametern.
- Unterschiedliche Reihenfolge der Parameter.
- Optionale Parameter.
- Benannte Argumente.
Wie funktioniert das Überladen von Methoden in C #?
Wie wird die entsprechende Methode basierend auf den Argumenten / Parametern aufgerufen? Nun, der Compiler überprüft während der Kompilierung jede Methodendefinition und bindet die Methodenaufrufe an die jeweiligen Definitionen. Falls es zwei gleichnamige Methoden gibt, prüft der Compiler die Signatur der Methoden und bindet die entsprechende Definition an den Aufruf. Selbst wenn die Signaturen die Mehrdeutigkeit nicht auflösen können, sucht der Compiler nach der impliziten Konvertierung von Argumenten, die mit den Signaturen übereinstimmen. Wenn eine implizite Konvertierung zu einer Signaturübereinstimmung führt, wird die Bindung durchgeführt. Wenn nicht, generiert der Compiler einen Fehler.
Wir werden uns in diesem Artikel verschiedene Beispiele ansehen, um die Funktionsweise des Compilers bei verschiedenen Arten von Methodenüberladung zu verstehen.
Arten des Methodenüberladens in C #
Hier werden die verschiedenen Arten der Methodenüberladung in C # beschrieben:
1. Unterschiedliche Anzahl von Parametern
Die erste und einfachste Kategorie der Methodenüberladung besteht darin, dass die Methoden eine unterschiedliche Anzahl von Parametern in ihren Signaturen aufweisen.
Code
Das folgende Beispiel ist ziemlich einfach und ein Kinderspiel.
using System;
public class Program
(
public static void Main()
(
Func(10);)
public static void Func(int a)
(
Console.WriteLine("Single Parameter");
)public static void Func(int a, int b)
(
Console.WriteLine("Multiple Parameters");
)
)
Ausgabe:
2. Unterschiedliche Arten von Parametern
Wenn die Methodensignaturen Parameter haben, die sich in den Typen unterscheiden. Die Anzahl der Parameter kann gleich sein oder auch nicht.
Beispiel 1
Im folgenden Beispiel erwarten beide Methoden ein einziges Argument. Ausgehend vom Typ des beim Methodenaufruf übergebenen Arguments bindet der Compiler die entsprechende Methodendefinition.
Code
using System;
public class Program
(
public static void Main()
(
Func("Hello World");
)
public static void Func(int a)
(
Console.WriteLine("Integer Parameter");
)
public static void Func(string b)
(Console.WriteLine("String Parameter");
)
)
Ausgabe:
Beispiel 2
Lassen Sie uns nun dem Compiler etwas zum Nachdenken geben. Wir würden eine Methode vom Typ double und float überladen. Wir wissen, dass eine Ganzzahl immer implizit sowohl in einen Float-Typ als auch in einen Double-Typ konvertiert werden kann.
Wenn wir ein Integer-Argument übergeben, prüft der Compiler, ob implizite Konvertierungen vorliegen, und stellt fest, dass die bestmögliche Konvertierung eine Gleitkommazahl ist. Daher heißt die float-Methode.
Code
using System;
public class Program
(
public static void Main()
(
Func(10);
)
public static void Func(double a)
(
Console.WriteLine("Double Parameter");
)
public static void Func(float b)
(
Console.WriteLine("Floating Point Parameter");
)
)
Ausgabe:
3. Unterschiedliche Reihenfolge der Parameter
Wenn Anzahl und Art der Argumente identisch sind, sich jedoch die Reihenfolge ihrer Übergabe unterscheidet.
Beispiel 1
Das folgende Beispiel ist ziemlich einfach.
Code
using System;
public class Program
(
public static void Main()
(
Func(10, 0.1);
)
public static void Func(int a, double b)
(
Console.WriteLine("Int-Double Parameters");
)
public static void Func(double a, int b)
(
Console.WriteLine("Double-Int Parameter");
)
)
Ausgabe:
Beispiel 2
Was würde passieren, wenn wir im obigen Beispiel zwei ganzzahlige Argumente übergeben? Lass es uns herausfinden.
Code
Func(10, 1);
Ausgabe:
4. Optionale Parameter
Wenn wir einen optionalen Parameter in der Methodensignatur definieren, behandelt der Compiler ihn als Methodenüberladung.
Hinweis: Dies hat Vorrang vor der impliziten Konvertierung.
Lassen Sie uns dies anhand eines Beispiels verstehen.
Beispiel
Im folgenden Beispiel geben wir dem Compiler zwei Möglichkeiten. Entweder kann das Argument implizit so konvertiert werden, dass es mit der Methodensignatur übereinstimmt. Oder es kann den Standardwert des optionalen Arguments übergeben. Der Compiler bevorzugt den letzteren Ansatz.
Code
using System;
public class Program
(
public static void Main()
(
Func(10);
)
public static void Func(int a, int b = 1)
(
Console.WriteLine("Int-Int Parameters");
)
public static void Func(double a)
(
Console.WriteLine("Double Parameter");
)
)
Ausgabe:
5. Benannte Argumente
C # bietet eine weitere Möglichkeit, den Namen der Argumente beim Aufruf der Methode zu übergeben. Dies hilft auch beim Überladen von Methoden. Entwickler können eine bestimmte Methode auch dann aufrufen, wenn das übergebene Argument standardmäßig eine andere Methode aufgerufen hat. Die überladenen Methoden müssen sich jedoch in der Signatur unterscheiden.
Beispiel
Im folgenden Beispiel weisen wir den Compiler an, eine bestimmte Methode aufzurufen, indem der Name des Parameters übergeben wird. Der Compiler setzt dann seine Logik zur Ermittlung der am besten geeigneten Methode aus.
Code
using System;
public class Program
(
public static void Main()
(
Func(b: 10);
)
public static void Func(int a)
(
Console.WriteLine("Int-Int Parameters");
)
public static void Func(double b)
(
Console.WriteLine("Double Parameter");
)
)
Ausgabe:
Regeln für das Überladen von Methoden in C #
Die folgenden Regeln müssen beim Überladen von Methoden in Ihrer C # -Anwendung beachtet werden.
- Die Methodensignatur muss unterschiedlich sein. Entweder muss die Anzahl der Argumente, die Art der Argumente oder die Reihenfolge der Argumente unterschiedlich sein.
- Der Rückgabetyp der Methoden spielt bei der Methodenüberladung keine Rolle.
- Optionale Parameter haben Vorrang vor der impliziten Typkonvertierung, wenn entschieden wird, welche Methodendefinition gebunden werden soll.
- Die implizite Typkonvertierung hat Vorrang vor der übergeordneten Klassenmethode.
Übung - Um dies zu verstehen, folgt eine kleine Übung für Sie. Erstellen Sie eine übergeordnete Klasse mit einer Methode, die eine Ganzzahl erwartet. Vererben Sie eine untergeordnete Klasse. Überladen Sie die Methode aus der übergeordneten Klasse in der untergeordneten Klasse, sodass die untergeordnete Klassenmethode ein Argument vom Typ double erwartet. Erstellen Sie ein Objekt der untergeordneten Klasse und rufen Sie die überladene Methode auf, die eine Ganzzahl übergibt. Schau was passiert.
Fazit
Methodenüberladung ist ein ziemlich leistungsfähiges Konzept. Es ist sehr hilfreich beim Schreiben von elegantem Code. Es kann jedoch zu einem gewissen Ausmaß kommen, wenn Dutzende von Methoden überlastet sind und der Entwickler beim Debuggen der fehlerhaften Aufrufe auf die Methodendefinitionen verweisen muss. Um dies zu vermeiden, wird häufig empfohlen, Ihre Methoden anders zu benennen, wenn das Überladen dazu neigt, auf eine höhere Ebene zu skalieren.
Empfohlene Artikel
Dies ist eine Anleitung zum Überladen in C #. Hier diskutieren wir seine Methode, wie es funktioniert, Typen mit Beispiel und Regeln. Sie können auch unsere anderen Artikelvorschläge durchgehen, um mehr zu erfahren -
- C # While-Schleife
- C # if-Anweisung
- C # -Funktionen
- Verwendung von C #
- Anleitung zum Überladen in C ++
- Überladen in Java
- Python-Überladung
- Überladen und Überschreiben in C #
- Typkonvertierung in Java mit Typen und Beispielen