Java Methodenüberladung: gleicher Name, andere Parameter

Ein Name, mehrere Versionen

Auf der vorherigen Seite hast du gesehen, wie die Parameter einer Methode festlegen, was sie akzeptiert. Die Methodenüberladung geht noch weiter: Du kannst mehreren Methoden denselben Namen geben, solange sich ihre Parameterlisten unterscheiden. Der Compiler behandelt sie als eigenständige Methoden und wählt anhand der übergebenen Argumente die passende aus.

Deshalb gibt System.out.println problemlos einen int, einen String, einen boolean oder einen double aus - es gibt nicht ein einziges println, sondern viele Überladungen, die sich den Namen teilen. Du schreibst den gemeinten Aufruf, und der Compiler ordnet ihn der passenden Version zu.

public class Main {
    static int square(int n) {
        return n * n;
    }

    static double square(double n) {
        return n * n;
    }

    public static void main(String[] args) {
        System.out.println(square(5));      // ruft die int-Version auf  -> 25
        System.out.println(square(2.5));    // ruft die double-Version auf -> 6.25
    }
}

Beide Methoden heißen square, aber eine nimmt einen int und die andere einen double. Das Literal 5 ist ein int, daher läuft die erste Überladung; 2.5 ist ein double, daher läuft die zweite.

Was als unterschiedliche Überladung zählt

Überladungen müssen sich in ihrer Parameterliste unterscheiden - das heißt in mindestens einem der folgenden Punkte:

• eine andere Anzahl von Parametern,
• andere Parametertypen oder
• eine andere Reihenfolge der Typen.

public class Main {
    static String join(String a, String b) {
        return a + b;
    }

    static String join(String a, String b, String c) {   // andere Anzahl
        return a + b + c;
    }

    static String join(String a, int times) {             // andere Typen
        return a.repeat(times);
    }

    public static void main(String[] args) {
        System.out.println(join("a", "b"));
        System.out.println(join("a", "b", "c"));
        System.out.println(join("hi", 3));
    }
}

Jeder Aufruf hat eine Parameterliste, die genau zu einer der drei join-Methoden passt, also gibt es keine Verwechslung.

Der Rückgabetyp zählt nicht

Eine häufige Anfängerfalle: zu versuchen, allein über den Rückgabetyp zu überladen. Der Rückgabetyp ist nicht Teil der Signatur, die der Compiler verwendet, daher lässt sich dies nicht kompilieren:

// Kompiliert NICHT - gleicher Name, gleiche Parameter, nur der Rückgabetyp unterscheidet sich
static int   value() { return 1; }
static double value() { return 1.0; }   // Fehler: value() ist bereits definiert

Der Compiler kann sie nicht auseinanderhalten, denn an einer Aufrufstelle wie value() deutet nichts in den Argumenten darauf hin, welche du meinst. Du darfst Überladungen unterschiedliche Rückgabetypen geben, aber nur, wenn sich ihre Parameterlisten bereits unterscheiden.

Wie Java eine Überladung auswählt

Wenn mehr als eine Überladung deine Argumente akzeptieren könnte, wählt Java die spezifischste und bevorzugt eine exakte Typübereinstimmung gegenüber einer erweiternden Umwandlung. Sieh dir an, was mit einem int-Argument passiert:

public class Main {
    static void show(int n)    { System.out.println("int: " + n); }
    static void show(long n)   { System.out.println("long: " + n); }
    static void show(double n) { System.out.println("double: " + n); }

    public static void main(String[] args) {
        show(7);     // exakte Übereinstimmung -> int
        show(7L);    // exakte Übereinstimmung -> long
        show(7.0);   // exakte Übereinstimmung -> double
    }
}

show(7) passt exakt zu int, obwohl long und double nach einer Erweiterung ebenfalls eine 7 aufnehmen könnten. Erst wenn die exakte Überladung entfernt würde, würde der Compiler int zu long und dann zu double erweitern. Diese Auflösung wird vollständig zur Kompilierzeit entschieden, anhand der deklarierten Typen deiner Argumente.

Achtung bei mehrdeutigen Aufrufen

Wenn keine einzelne Überladung eindeutig die beste Übereinstimmung ist, weigert sich der Compiler zu raten und meldet einen Fehler. Das passiert am häufigsten mit null, das zu jedem Referenztyp passt:

static void handle(String s) { }
static void handle(StringBuilder b) { }

handle(null);   // Fehler: die Referenz auf handle ist mehrdeutig

Beide Überladungen akzeptieren null, und keine ist spezifischer, daher kompiliert der Aufruf nicht. Behebe es, indem du den Typ mit einem Cast explizit machst - handle((String) null) - oder das Design so änderst, dass die Überladungen nicht kollidieren. Dieselbe Vorsicht gilt beim Mischen von Autoboxing und Erweiterung; halte Überladungssätze einfach genug, damit jeder Aufruf einen offensichtlichen Gewinner hat.

Konstruktoren überladen

Überladung ist nicht auf gewöhnliche Methoden beschränkt - Konstruktoren nutzen sie ständig, um mehrere Wege zum Erstellen eines Objekts anzubieten. Ein parameterloser Konstruktor kann mit this(...) an einen vollständigeren delegieren:

public class Main {
    static class Point {
        int x, y;

        Point() {
            this(0, 0);          // an den Konstruktor mit zwei Argumenten delegieren
        }

        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public String toString() {
            return "(" + x + ", " + y + ")";
        }
    }

    public static void main(String[] args) {
        System.out.println(new Point());      // (0, 0)
        System.out.println(new Point(3, 4));  // (3, 4)
    }
}

Beide Konstruktoren teilen sich den Namen Point, unterscheiden sich aber in der Parameteranzahl, genau wie überladene Methoden. Das Delegieren mit this(...) hält die Initialisierungslogik an einer Stelle.

Überladung vs. Überschreibung

Diese beiden klingen ähnlich, haben aber nichts miteinander zu tun:

• Überladung - gleicher Name, unterschiedliche Parameterlisten, in derselben Klasse. Der Compiler wählt die Version zur Kompilierzeit. Es geht darum, Varianten einer Operation anzubieten.
• Überschreibung - eine Unterklasse definiert eine geerbte Methode mit gleichem Namen und gleichen Parametern neu. Java wählt die Version zur Laufzeit anhand des tatsächlichen Objekttyps. Es geht darum, Verhalten zu ersetzen (du begegnest ihr bei Vererbung und Polymorphie).

Sind die Parameterlisten identisch, überschreibst du (oder verursachst einen Fehler wegen doppelter Methode in derselben Klasse); unterscheiden sie sich, überlädst du.

Als Nächstes: Varargs

Mit der Überladung kannst du join(a, b) und join(a, b, c) als getrennte Methoden schreiben - aber was, wenn du eine beliebige Anzahl von Argumenten akzeptieren willst, ohne für jede Anzahl eine Überladung zu deklarieren? Javas varargs-Syntax erlaubt es einer einzigen Methode, eine Argumentliste variabler Länge zu nehmen, und das ist das Thema der nächsten Seite.