Methodenüberladung

Methodenüberladung in C# ermöglicht es Ihnen, mehrere Methoden mit demselben Namen in einer Klasse zu definieren, die sich jeweils in ihren Parametertypen, der Anzahl der Parameter oder beidem unterscheiden. Dies bietet eine sauberere und anpassungsfähigere Möglichkeit, verschiedene Eingabeszenarien zu handhaben.

Zum Beispiel können wir zwei Methoden mit demselben Namen, aber unterschiedlicher Anzahl von Parametern haben:

index


              12345678910111213141516171819
            
using System;
class ConsoleApp
{
    static int sum(int a, int b)
    {
        return a + b;
    }

    static int sum(int a, int b, int c)
    {
        return a + b + c;
    }

    static void Main()
    {
        Console.WriteLine(sum(5, 7));
        Console.WriteLine(sum(5, 7, 9));
    }
}

Im obigen Code wurde die sum-Methode überladen, um zwei Varianten von Parametern zu haben. Eine Methode kann auch unterschiedliche Rückgabetypen für verschiedene Varianten von sich selbst haben, jedoch ist es wichtig, dass keine Mehrdeutigkeit besteht, da der Compiler sonst einen Fehler anzeigt, weil die primäre Methode für einen Compiler, zwischen zwei Methoden mit demselben Namen zu unterscheiden, ihre Parameterliste ist.

Zum Beispiel:

index


              12345678910
            
static int sum(int a, int b)
{
    return a + b;
}

// This is wrong and will show an error
static long sum(int a, int b)
{
    return a + b;
}

Der obige Code ist falsch, weil die Parameter genau die gleichen wie bei der ursprünglichen Methode sind, während der Rückgabetyp unterschiedlich ist. Dies ist nicht erlaubt, da es unmöglich macht, für den Compiler (oder sogar für Menschen) zu wählen, welche Methode ausgeführt werden soll, wenn die Methode aufgerufen wird:

index


              123
            
sum(1, 3); 
// Should it execute `int sum(int a, int b)` or `long sum(int a, int b)` ? 
// It is impossible to reach a good answer for the compiler in this case so it shows an error

Deshalb sollte eine Methode, die einen anderen Rückgabetyp hat, beim Überladen einer Methode auch eine andere Menge von Parametern haben, um sie unterscheidbar zu machen und Mehrdeutigkeiten zu beseitigen. Das Folgende ist ebenfalls falsch:

index


              12345678910
            
static int sum(int a, int b)
{
    return a + b;
}

// This is wrong and will show an error
static long sum(int first, int second)
{
    return first + second;
}

Es liegt daran, dass die Namen der Parameter keine Rolle spielen, aber ihre Typen schon. Die folgenden Überladungsfälle sind gültig:

index


              1234567891011121314151617181920212223242526
            
using System;
class ConsoleApp
{
    static int sum(int a, int b)
    {
        return a + b;
    }

    static long sum(long a, long b)
    {
        return a + b;
    }

    static string sum(int a, long b, float c)
    {
        return Convert.ToString(a + b + c);
    }

    static void Main()
    {
        Console.WriteLine(sum(5, 7)); // Calls 'int sum()'
        Console.WriteLine(sum(500000000000, 700000000000)); // Calls 'long sum()'
        Console.WriteLine(sum(5, 7, 9)); // Calls 'string sum()'
    }
}

1. Wie unterscheidet der Compiler zwischen überladenen Methoden?

2. Welches der folgenden Beispiele ist ein gültiges Beispiel für Methodenüberladung?

War alles klar?

Danke für Ihr Feedback!

Abschnitt 4. Kapitel 7