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 Objekten, sich je nach Kontext unterschiedlich zu verhalten. Eine Form des Polymorphismus ist die Methodenüberladung, die auch als Polymorphismus zur Kompilierzeit bezeichnet wird, da Java 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

Erstellen wir einen Nachrichtenformatierer, der Methodenüberladung demonstriert, indem er mehrere Möglichkeiten zum Formatieren von Nachrichten bereitstellt. Du erstellst eine Hilfsklasse mit mehreren überladenen format-Methoden, die verschiedene Eingabeszenarien behandeln.

Du organisierst deinen Code über zwei Dateien:

MessageFormatter.java: Erstelle eine Klasse, die durch überladene Methoden eine flexible Nachrichtenformatierung ermöglicht. Dein Formatierer sollte Folgendes enthalten:
- Eine Methode format(String message), die die Nachricht in eckigen Klammern zurückgibt: [message]
- Eine Methode format(String message, int repeatCount), die die Nachricht so oft wiederholt, wie angegeben, und die Wiederholungen durch Leerzeichen trennt
- Eine Methode format(String message, String prefix), die die Nachricht mit dem Präfix verbindet: prefix: message
- Eine Methode format(String message, String prefix, String suffix), die Folgendes zurückgibt: prefix: message (suffix)
Der Compiler wählt anhand der von dir übergebenen Argumente die richtige Methode aus – das ist Polymorphismus zur Kompilierzeit in Aktion!
Main.java: Zeige, wie alle vier überladenen Methoden zusammenarbeiten. Du erhältst vier Eingaben: eine Nachricht (String), eine Wiederholungsanzahl (int), ein Präfix (String) und ein Suffix (String). Erstelle einen MessageFormatter und rufe jede Variante der format-Methode auf, wobei du jedes Ergebnis in einer eigenen Zeile ausgibst:
- Erstens: Formatierung nur mit der Nachricht
- Zweitens: Formatierung mit der Nachricht und der Wiederholungsanzahl
- Drittens: Formatierung mit der Nachricht und dem Präfix
- Viertens: Formatierung mit der Nachricht, dem Präfix und dem Suffix

Du erhältst vier Eingaben: den Nachrichtentext, die Anzahl der Wiederholungen, einen Präfix-String und einen Suffix-String.

Wenn die Nachricht beispielsweise „Hello“ lautet, die Wiederholungsanzahl 3, das Präfix „INFO“ und das Suffix „done“ ist, sollte deine Ausgabe vier verschiedene formatierte Versionen derselben Nachricht zeigen, wobei jede eine andere überladene Methode verwendet!

REQUIRED OUTPUT FORMAT: [Your translated content here]

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
        
    }
}