Methodenüberladung

Teil des Abschnitts Objektorientierte Programmierung der C#-Journey von Coddy — Lektion 50 von 70.

Methodenüberladung ermöglicht es Ihnen, mehrere Methoden mit demselben Namen, aber unterschiedlichen Parameterlisten zu definieren. Der Compiler bestimmt basierend auf den von Ihnen bereitgestellten Argumenten, welche Version aufgerufen werden soll.

Jede überladene Methode muss eine eindeutige Signatur haben – entweder eine unterschiedliche Anzahl von Parametern oder unterschiedliche Parametertypen:

public static void Print(string message)
{
    Console.WriteLine(message);
}

public static void Print(string message, int times)
{
    for (int i = 0; i < times; i++)
        Console.WriteLine(message);
}

public static void Print(int number)
{
    Console.WriteLine(number);
}

// Der Compiler wählt die richtige Version
Print("Hello");           // Ruft Print(string) auf
Print("Hi", 3);           // Ruft Print(string, int) auf
Print(42);                // Ruft Print(int) auf

Überladung unterscheidet sich von optionalen Parametern in einem wichtigen Punkt. Bei optionalen Parametern haben Sie eine Methode, die mehrere Szenarien verarbeitet. Bei der Überladung haben Sie separate Methoden, die für jeden Fall völlig unterschiedliche Logik enthalten können.

Beachten Sie, dass der Rückgabetyp allein Methoden nicht eindeutig macht – Sie können nicht zwei Methoden haben, die sich nur durch ihren Rückgabetyp unterscheiden. Die Parameterliste muss unterschiedlich sein. Methodenüberladung ist eine Form des Polymorphismus zur Kompilierzeit, bei der die Entscheidung darüber, welche Methode aufgerufen werden soll, beim Kompilieren des Codes getroffen wird und nicht zur Laufzeit.

Aufgabe

Einfach

Lassen Sie uns eine vielseitige Taschenrechner-Klasse erstellen, die die Leistungsfähigkeit der Methodenüberladung demonstriert. Sie werden mehrere Versionen von Berechnungsmethoden erstellen, die verschiedene Szenarien abdecken – von einfachen Operationen mit zwei Zahlen bis hin zu komplexeren Berechnungen – und dabei alle dieselben intuitiven Methodennamen verwenden.

Sie werden Ihren Code in zwei Dateien organisieren:

Calculator.cs: Erstellen Sie eine Calculator-Klasse im Namespace MathTools mit überladenen Methoden, die denselben Namen haben, aber unterschiedliche Parameter akzeptieren:
- Multiply - Erstellen Sie drei überladene Versionen:
  - Eine, die zwei int-Parameter entgegennimmt und deren Produkt als int zurückgibt
  - Eine, die drei int-Parameter entgegennimmt und deren Produkt als int zurückgibt
  - Eine, die zwei double-Parameter entgegennimmt und deren Produkt als double zurückgibt
- Describe - Erstellen Sie zwei überladene Versionen:
  - Eine, die ein int entgegennimmt und "Integer: {value}" zurückgibt
  - Eine, die ein double entgegennimmt und "Double: {value}" zurückgibt
Program.cs: Erstellen Sie in Ihrer Hauptdatei eine Calculator-Instanz und demonstrieren Sie, wie der Compiler automatisch die richtige überladene Methode basierend auf den von Ihnen bereitgestellten Argumenten auswählt.

Sie erhalten vier Eingaben:

Erste Ganzzahl (z. B. 5)
Zweite Ganzzahl (z. B. 4)
Dritte Ganzzahl (z. B. 3)
Eine Dezimalzahl (z. B. 2.5)

Führen Sie mit Ihrem Taschenrechner diese Operationen aus und geben Sie jedes Ergebnis in einer eigenen Zeile aus:

Multiplizieren Sie die ersten beiden Ganzzahlen (verwendet die Version mit zwei Integern)
Multiplizieren Sie alle drei Ganzzahlen (verwendet die Version mit drei Integern)
Multiplizieren Sie die erste Ganzzahl und die Dezimalzahl (verwendet die Version mit zwei Doubles)
Beschreiben Sie die erste Ganzzahl (verwendet die Integer-Version)
Beschreiben Sie die Dezimalzahl (verwendet die Double-Version)

Wenn die Eingaben beispielsweise 5, 4, 3 und 2.5 sind, sollte die Ausgabe wie folgt aussehen:

20
60
12.5
Integer: 5
Double: 2.5

Beachten Sie, wie Sie Multiply und Describe mit unterschiedlichen Argumenttypen und -anzahlen aufrufen, der Compiler jedoch genau weiß, welche Version er jedes Mal verwenden muss. Dies ist Polymorphie zur Kompilierzeit in Aktion – die Entscheidung fällt beim Kompilieren Ihres Codes, nicht während der Laufzeit!

Spickzettel

Methodenüberladung ermöglicht es Ihnen, mehrere Methoden mit demselben Namen, aber unterschiedlichen Parameterlisten zu definieren. Der Compiler bestimmt anhand der bereitgestellten Argumente, welche Version aufgerufen werden soll.

Jede überladene Methode muss eine eindeutige Signatur haben – entweder eine unterschiedliche Anzahl von Parametern oder unterschiedliche Parametertypen:

public static void Print(string message)
{
    Console.WriteLine(message);
}

public static void Print(string message, int times)
{
    for (int i = 0; i < times; i++)
        Console.WriteLine(message);
}

public static void Print(int number)
{
    Console.WriteLine(number);
}

// Der Compiler wählt die richtige Version
Print("Hello");           // Ruft Print(string) auf
Print("Hi", 3);           // Ruft Print(string, int) auf
Print(42);                // Ruft Print(int) auf

Wichtige Punkte zur Methodenüberladung:

Überladung unterscheidet sich von optionalen Parametern – bei der Überladung haben Sie separate Methoden, die für jeden Fall eine völlig unterschiedliche Logik enthalten können
Der Rückgabetyp allein macht Methoden nicht eindeutig – die Parameterliste muss unterschiedlich sein
Methodenüberladung ist eine Form des Polymorphismus zur Kompilierzeit, bei der die Entscheidung, welche Methode aufgerufen werden soll, beim Kompilieren des Codes getroffen wird und nicht während der Laufzeit

Probier es selbst

using System;
using MathTools;

class Program
{
    public static void Main(string[] args)
    {
        // Eingaben lesen
        int firstInt = Convert.ToInt32(Console.ReadLine());
        int secondInt = Convert.ToInt32(Console.ReadLine());
        int thirdInt = Convert.ToInt32(Console.ReadLine());
        double decimalNum = Convert.ToDouble(Console.ReadLine());

        // TODO: Eine Calculator-Instanz erstellen

        // TODO: Multiply mit zwei Ganzzahlen aufrufen und das Ergebnis ausgeben

        // TODO: Multiply mit drei Ganzzahlen aufrufen und das Ergebnis ausgeben

        // TODO: Multiply mit der ersten Ganzzahl und der Dezimalzahl aufrufen, das Ergebnis ausgeben

        // TODO: Describe mit der ersten Ganzzahl aufrufen und das Ergebnis ausgeben

        // TODO: Describe mit der Dezimalzahl aufrufen und das Ergebnis ausgeben
    }
}