Grundlagen der Methodenüberladung

Teil des Abschnitts Objektorientierte Programmierung der Java-Journey von Coddy — Lektion 28 von 87.

Polymorphismus bedeutet „viele Formen“. In Java ermöglicht er es Objekten, sich je nach Kontext unterschiedlich zu verhalten. Eine Form des Polymorphismus ist das Überladen von Methoden (method overloading), auch Kompilierzeit-Polymorphismus genannt, da Java bereits während der Kompilierung bestimmt, welche Methode aufgerufen werden soll.

Methodenüberladung ermöglicht es Ihnen, mehrere Methoden mit demselben Namen, aber unterschiedlichen Parametern zu definieren. Der Compiler unterscheidet zwischen ihnen basierend auf der Anzahl, dem Typ oder der Reihenfolge der Parameter:

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
}

Wenn Sie add(5, 3) aufrufen, verwendet Java die erste Methode. Der Aufruf von add(5, 3, 2) löst die zweite aus, und add(5.0, 3.0) ruft die dritte auf. Der Compiler wählt basierend auf den von Ihnen angegebenen Argumenten die richtige Version aus.

Beachten Sie, dass das Ändern nur des Rückgabetyps kein gültiges Überladen ist. Die Parameterliste muss sich unterscheiden:

// KEIN gültiges Überladen - wird nicht kompiliert
public int getValue() { return 1; }
public double getValue() { return 1.0; }  // Fehler!

Sie haben Überladung bereits bei der Konstruktor-Überladung kennengelernt. Methodenüberladung folgt denselben Regeln und bietet Flexibilität, indem sie es einem Methodennamen ermöglicht, verschiedene Eingabeszenarien zu verarbeiten.

Aufgabe

Einfach

Lassen Sie uns einen Nachrichtenformatierer erstellen, der das Überladen von Methoden demonstriert, indem er mehrere Möglichkeiten zur Formatierung von Nachrichten bietet. Sie werden eine Hilfsklasse mit mehreren überladenen format-Methoden erstellen, die verschiedene Eingabeszenarien verarbeiten.

Sie werden Ihren Code auf zwei Dateien verteilen:

MessageFormatter.java: Erstellen Sie eine Klasse, die eine flexible Nachrichtenformatierung durch überladene Methoden bietet. Ihr Formatierer sollte Folgendes enthalten:
- Eine Methode format(String message), die die in Klammern eingeschlossene Nachricht zurückgibt: [message]
- Eine Methode format(String message, int repeatCount), die die Nachricht so oft wiederholt zurückgibt, wie angegeben, getrennt durch Leerzeichen
- Eine Methode format(String message, String prefix), die die Nachricht mit dem vorangestellten Präfix zurückgibt: prefix: message
- Eine Methode format(String message, String prefix, String suffix), die Folgendes zurückgibt: prefix: message (suffix)
Der Compiler wählt die richtige Methode basierend auf den übergebenen Argumenten aus – das ist Polymorphie zur Kompilierzeit in Aktion!
Main.java: Demonstrieren Sie alle vier überladenen Methoden im Zusammenspiel. Sie erhalten vier Eingaben: eine Nachricht (String), eine Wiederholungsanzahl (int), ein Präfix (String) und ein Suffix (String). Erstellen Sie einen MessageFormatter und rufen Sie jede Version der format-Methode auf, wobei jedes Ergebnis in einer eigenen Zeile ausgegeben wird:
- Zuerst formatieren Sie nur mit der Nachricht
- Zweitens formatieren Sie mit der Nachricht und der Wiederholungsanzahl
- Drittens formatieren Sie mit der Nachricht und dem Präfix
- Viertens formatieren Sie mit der Nachricht, dem Präfix und dem Suffix

Sie erhalten vier Eingaben: den Nachrichtentext, wie oft er wiederholt werden soll, einen Präfix-String und einen Suffix-String.

Wenn die Nachricht beispielsweise "Hello" ist, die Wiederholungsanzahl 3, das Präfix "INFO" und das Suffix "done", sollte Ihre Ausgabe vier verschiedene formatierte Versionen derselben Nachricht zeigen, die jeweils eine andere überladene Methode verwenden!

Spickzettel

Methodenüberladung ermöglicht es Ihnen, mehrere Methoden mit dem gleichen Namen, aber unterschiedlichen Parametern zu definieren. Dies wird auch als Kompilierzeit-Polymorphismus bezeichnet, da Java während der Kompilierung bestimmt, welche Methode aufgerufen werden soll.

Der Compiler unterscheidet überladene Methoden basierend auf der Anzahl, dem Typ oder der Reihenfolge der Parameter:

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
}

Beim Aufruf von add(5, 3) verwendet Java die erste Methode. Der Aufruf von add(5, 3, 2) löst die zweite aus, und add(5.0, 3.0) ruft die dritte auf.

Wichtig: Nur den Rückgabetyp zu ändern, ist keine gültige Überladung. Die Parameterliste muss sich unterscheiden:

// KEINE gültige Überladung
public int getValue() { return 1; }
public double getValue() { return 1.0; }  // Fehler!

Probier es selbst

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Eingaben lesen
        String message = scanner.nextLine();
        int repeatCount = Integer.parseInt(scanner.nextLine());
        String prefix = scanner.nextLine();
        String suffix = scanner.nextLine();
        
        // TODO: Erstelle ein MessageFormatter Objekt
        
        // TODO: Rufe format nur mit message auf und gib das Ergebnis aus
        
        // TODO: Rufe format mit message und repeatCount auf und gib das Ergebnis aus
        
        // TODO: Rufe format mit message und prefix auf und gib das Ergebnis aus
        
        // TODO: Rufe format mit message, prefix und suffix auf und gib das Ergebnis aus
        
    }
}