Java-Methoden und Problemzerlegung

Eine Methode ist ein benannter Block von Anweisungen, der eine Aufgabe erfüllt. Die Definition einer Methode stellt die Aufgabe bereit; ihr Aufruf führt sie aus.

Lies Kopf und Rumpf

public static void printLine() {
    System.out.println("----------");
}

Die erste Zeile ist der Methodenkopf. Lies seine Teile von links nach rechts:

• public erlaubt Code in anderen Klassen, die Methode aufzurufen.
• static ordnet die Methode der Klasse zu. Für ihren Aufruf ist kein Objekt nötig.
• void besagt, dass die Methode keinen Wert zurückgibt.
• printLine benennt die Aufgabe.
• () ist die leere Parameterliste: Diese Methode benötigt keine Eingabe.

Die geschweiften Klammern umschließen den Methodenrumpf, also die Anweisungen, die bei einem Aufruf ausgeführt werden. Zwischen diesem Kopf und seiner öffnenden Klammer steht kein Semikolon.

Setze die Definition in die Klasse

public class Main {
    public static void main(String[] args) {
        System.out.println("Start");
        printLine();
        System.out.println("Middle");
        printLine();
    }

    public static void printLine() {
        System.out.println("----------");
    }
}

main und printLine sind getrennte Methoden innerhalb von Main. Die schließende Klammer von main steht vor der Definition von printLine. Eine Methode kann nicht innerhalb einer anderen Methode definiert werden; eine falsch gesetzte Klammer kann „illegal start of expression“ verursachen.

Die Definitionen können in beliebiger Reihenfolge stehen. Wenn du printLine über main verschiebst, ändert das nicht, wann die Methode ausgeführt wird. Eine Methode, die nie aufgerufen wird, wird nicht allein deshalb ausgeführt, weil ihre Definition in der Datei steht.

Verfolge einen Aufruf und die Rückkehr zum Aufrufer

Der Aufruf printLine(); besteht aus dem Namen, Klammern und einem Semikolon, weil der Aufruf als eigene Anweisung steht. Die Ausführung beginnt in main:

1. Gib „Start“ aus.
2. Wechsle zu printLine, gib zehn Bindestriche aus und fahre dann nach dem Aufruf fort.
3. Gib „Middle“ aus.
4. Wechsle erneut zu printLine und gib erneut zehn Bindestriche aus.

Die Ausgabe lautet:

Start
----------
Middle
----------

Beide Aufrufe verwenden dieselbe Definition. Änderst du die ausgegebene Zeile, ändert sie sich an beiden Stellen, die sie verwenden.

Benenne Methoden genau und rufe sie korrekt auf

Verwende ein Verb oder eine Verbgruppe in camelCase mit kleinem Anfangsbuchstaben: printReceipt, calculateAverage oder isValidCode. Java unterscheidet Groß- und Kleinschreibung: PrintLine() findet keine Methode namens printLine. Auch printLine; schlägt fehl; die Klammern gehören zum Aufruf.

Schreibe bei einer statischen Methode in einer anderen Klasse zuerst den Klassennamen. Math.max(3, 8) ergibt 8, Math.abs(-4) ergibt 4 und Math.sqrt(16.0) ergibt 4.0. Deine eigenen Methoden in derselben Klasse kannst du allein über ihren Namen aufrufen.

Diese Beispiele verwenden die klassische klassenbasierte Form mit public static void main(String[] args). Java 25 unterstützt auch kompakte Quelldateien mit void main() und ohne umgebende Klasse. Behalte beim Ausführen dieser Beispiele die klassische Form bei; ihre Hilfsmethoden werden mit static deklariert. Methoden wie System.out.println, die du aus der Java-Bibliothek aufrufst, müssen nicht selbst statisch sein.

Ein Parameter ermöglicht es einer Methode, Werte zu verarbeiten, die sich von Aufruf zu Aufruf ändern. Ein Argument ist der Wert, der beim Aufruf der Methode für diesen Parameter übergeben wird.

Gib jeder Eingabe einen Typ und einen Namen

public static void printStars(int count) {
    for (int i = 0; i < count; i++) {
        System.out.print("*");
    }
    System.out.println();
}

int count deklariert einen Parameter. In printStars(3); wird das Argument 3 zum Anfangswert von count. Die Schleife läuft dreimal, gibt also *** aus; anschließend beendet println() die Zeile. printStars(8); verwendet denselben Rumpf mit dem Wert 8 für count.

Der Typ steht in der Definition, nicht im Aufruf. Schreibe printStars(5);, nicht printStars(int 5);.

Werte Argumente vor dem Eintritt in den Rumpf aus

Ein Argument kann ein Literal, eine Variable oder ein Ausdruck sein:

int n = 4;
printStars(n * 2);

Java wertet zuerst n * 2 aus. Es übergibt den resultierenden Wert 8, sodass der Rumpf mit dem Wert 8 für count beginnt. Der Variablenname beim Aufrufer muss nicht mit dem Parameternamen übereinstimmen.

Ordne mehrere Parameter nach Position zu

Jeder Parameter braucht seinen eigenen Typ. Eine Methode für Rechtecke kann mit diesem Kopf beginnen:

public static void printRectangle(int width, int height)

Der Aufruf printRectangle(5, 2); gibt width den Wert 5 und height den Wert 2. Vertauschst du die Argumente, erhältst du ein Rechteck mit Breite 2 und Höhe 5. Beide Aufrufe lassen sich kompilieren, weil beide Argumente int-Werte sind; nur die beabsichtigte Form zeigt dir, welche Reihenfolge richtig ist. (int width, height) im Kopf schlägt fehl, weil für height kein Typ deklariert ist.

Unterschiedliche Typen erleichtern es, manche Fehler in der Reihenfolge zu erkennen:

public static void printRepeated(String text, int times) {
    for (int i = 0; i < times; i++) {
        System.out.print(text);
    }
    System.out.println();
}

printRepeated("ab", 3); gibt „ababab“ aus. printRepeated(3, "ab"); passt nicht zu einem String gefolgt von einem int-Wert. Auch die Anzahl der Argumente muss passen: Bei printRectangle(5); erhält ein Parameter keinen Wert.

Prüfe kompatible numerische Typen

Java erweitert einen int-Wert automatisch zu einem double-Wert. Eine Methode mit den Parametern (double km, double hours) akzeptiert die Argumente (150, 2) und erhält dafür 150.0 und 2.0. Jeder int-Wert kann als double genau dargestellt werden.

Java wandelt ein double-Argument nicht implizit in einen int-Parameter um. printStars(2.9); schlägt fehl, weil bei der Umwandlung der Nachkommateil verloren ginge. Der explizite Cast in printStars((int) 2.9); ergibt 2, sodass zwei Sterne ausgegeben werden. Verwende einen Cast nur, wenn das Abschneiden dieses Teils beabsichtigt ist.

Wähle für jede Information, die die Aufgabe benötigt, einen Parameter. Da printRepeated Text und eine Anzahl erhält, lässt sich die Methode mit Tastatureingaben, einem festen Testaufruf oder aus einer anderen Methode verwenden. Ihr Rumpf muss nicht entscheiden, woher diese Werte stammen.

Ein Rückgabewert ist ein Ergebnis, das eine Methode an ihren Aufrufer zurückgibt. Sobald ein Aufruf endet, kann er als Ausdruck mit dem Typ dieses Ergebnisses verwendet werden.

Deklariere, was zurückgegeben wird

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

int ersetzt void im Kopf, weil diese Methode eine Ganzzahl zurückgibt. Die return-Anweisung wertet a + b aus und gibt den Wert an die Aufrufstelle zurück. Für sum(4, 7) ist dieser Wert 11.

Der Aufrufer entscheidet, was als Nächstes geschieht:

int total = sum(4, 7);
System.out.println(sum(4, 7));
int doubled = sum(2, 3) * 2;

Die erste Zeile speichert 11, die zweite gibt 11 aus und die dritte speichert 10. Ein Rückgabewert kann auch in einer Bedingung verwendet werden, etwa if (sum(a, b) > 10).

Ein kompatibles int-Ergebnis kann bei der Rückgabe aus einer double-Methode erweitert werden. Ein double-Ergebnis kann ohne passende explizite Umwandlung nicht aus einer int-Methode zurückgegeben werden.

Berechne den Ausdruck vor der Umwandlung des Ergebnisses

public static double average(int a, int b) {
    return (a + b) / 2.0;
}

Für average(3, 4) ist der Zähler 7. Die Division durch das double-Literal 2.0 ergibt 3.5. Lautete der Ausdruck (a + b) / 2, würde Java zuerst zwei int-Werte dividieren und 3 erhalten. Erst danach würde es diesen Wert zum Rückgabewert 3.0 erweitern. Ein double-Rückgabetyp macht eine bereits im Rumpf ausgeführte Ganzzahldivision nicht rückgängig.

Unterscheide Rückgabe und Ausgabe

Ein void-Aufruf kann keinen Wert in einer Zuweisung oder einem anderen Aufruf liefern. Ist printSum eine void-Methode, schlägt int total = printSum(1, 2); fehl, obwohl printSum eine Zahl ausgibt. Verwende für Berechnungen eine Methode mit Rückgabewert und überlasse dem Aufrufer die Entscheidung über die Ausgabe.

Gib Text und Ja-Nein-Ergebnisse zurück

Zu den Rückgabetypen gehören auch String und boolean. Eine Begrüßungsmethode kann "Hello, " + name + "!" zurückgeben, was für das Argument "Ana" „Hello, Ana!“ ergibt. Eine Methode isEven(int n) kann n % 2 == 0 zurückgeben.

Eine Formatierungsmethode wandelt eine Zahl in wiederverwendbaren Text um:

public static String formatDuration(int minutes) {
    return minutes / 60 + " h " + minutes % 60 + " min";
}

Für 135 ergibt die Ganzzahldivision 2 volle Stunden und der Divisionsrest 15 Minuten. Das Ergebnis ist „2 h 15 min“; für 60 ist es „1 h 0 min“.

Behalte oder kombiniere das Ergebnis

Ein Aufruf wie sum(4, 7); lässt sich kompilieren, verwirft aber sein Ergebnis. Gibt square(x) einen neuen Wert zurück, verwende x = square(x);, um ihn in x zu speichern.

Ein Ergebnis kann auch unmittelbar zum Argument werden. In Math.max(sum(1, 2), 4) ergibt sum(1, 2) zuerst 3, danach ergibt Math.max(3, 4) den Wert 4. Werte den inneren Aufruf aus, bevor du sein Ergebnis im äußeren verwendest.

Eine return-Anweisung beendet den aktuellen Methodenaufruf sofort. Auch innerhalb einer Bedingung oder Schleife verlässt sie die ganze Methode, nicht nur diesen Block.

Gib jedem Pfad eine Antwort

public static int larger(int a, int b) {
    if (a > b) {
        return a;
    }
    return b;
}

larger(9, 4) gibt innerhalb des if-Blocks 9 zurück. Bei larger(2, 6) wird der if-Rumpf übersprungen und das abschließende return gibt 6 zurück. Gleiche Eingaben wie (5, 5) erreichen ebenfalls das abschließende return, das 5 zurückgibt. Nach dem ersten return ist kein else nötig, weil dieser Pfad die Methode bereits verlassen hat.

In einer gewöhnlichen Methode mit Rückgabewert darf kein möglicher Pfad die schließende Klammer erreichen, ohne einen Wert zu liefern. Eine Vorzeichenmethode, die nur für positive und negative Eingaben zurückkehrt, lässt null ohne Antwort:

public static String sign(int n) {
    if (n > 0) {
        return "positive";
    } else if (n < 0) {
        return "negative";
    }
    return "zero";
}

Das abschließende return vervollständigt die Methode. Zwei getrennte if-Anweisungen, von denen eine n > 0 und die andere n <= 0 prüft, benötigen weiterhin ein abschließendes return oder eine eindeutige if/else-Struktur. Javas Rückgabeprüfung leitet nicht ab, dass diese beiden Vergleiche alle Ganzzahlen abdecken. Eine Anweisung direkt nach einem unbedingten return im selben Block ist unerreichbar und wird abgelehnt.

Beende eine Suche im richtigen Moment

public static int firstMultipleOf7(int start, int end) {
    for (int i = start; i <= end; i++) {
        if (i % 7 == 0) {
            return i;
        }
    }
    return -1;
}

Für (10, 20) verwirft die Schleife 10, 11, 12 und 13 und gibt dann 14 zurück. Der Aufruf endet, ohne 15 bis 20 zu prüfen. Für (15, 20) endet die Schleife ohne Treffer, sodass das return danach -1 zurückgibt, das vereinbarte Signal „nicht gefunden“.

Ein else { return -1; } innerhalb der Schleife würde nach dem ersten erfolglosen Kandidaten abbrechen. Die Suche ab 10 würde dann einen Misserfolg melden, bevor sie 14 erreicht. Die Rückgabe für einen Misserfolg gehört hinter die Schleife, nachdem alle Kandidaten geprüft wurden.

Gib die Bedingung selbst zurück

Ein Vergleich liefert bereits einen boolean-Wert. Schreibe return n % 2 == 0; statt eines if/else, das true und false getrennt zurückgibt. Der Name einer booleschen Methode beginnt oft mit is oder has, sodass sich ein Aufruf innerhalb eines if natürlich liest.

public static boolean isLeapYear(int year) {
    return (year % 4 == 0 && year % 100 != 0)
        || year % 400 == 0;
}

Dies gibt für 2024 und 2000 den Wert true, für 1900 und 2023 aber false zurück. Verwende if (isLeapYear(y)) direkt.

Verlasse eine void-Methode vorzeitig

Eine void-Methode verwendet return; ohne Wert. Zum Beispiel kann printSquareRoot(double x) bei einer negativen Eingabe „No real square root“ ausgeben und sofort zurückkehren. Für andere Eingaben kann die Methode Math.sqrt(x) ausgeben, das für 2.25 den Wert 1.5 ergibt. return 5; schlägt in einer void-Methode fehl, weil ihr Kopf keinen Rückgabewert verspricht.

Der Gültigkeitsbereich einer Variablen ist der Bereich des Codes, in dem ihr Name verwendet werden kann. Betrachte zuerst die geschweiften Klammern um ihre Deklaration: Ein lokaler Name gehört zu einer bestimmten Methode oder einem bestimmten Block.

Lokale Variablen des Aufrufers bleiben beim Aufrufer

public static void main(String[] args) {
    int price = 20;
    printDouble(price);
}

public static void printDouble(int price) {
    System.out.println(price * 2);
}

Das price in main und der Parameter price in printDouble sind getrennte Variablen. Das Argument liefert den Wert, den die Hilfsmethode benötigt, sodass sie 40 ausgibt.

Wenn du den Parameter entfernst und printDouble() aufrufst, kann die Hilfsmethode trotzdem nicht das lokale price von main lesen. Ihr Rumpf würde mit „cannot find symbol“ fehlschlagen. Der Aufruf einer Methode aus einer anderen verbindet ihre Gültigkeitsbereiche nicht. Verschiedene Methoden dürfen jeweils den Namen count verwenden, ohne ihre Variablen zu verbinden.

Ein verschachtelter Block schafft einen kleineren Gültigkeitsbereich

Eine lokale Variable kann von ihrer Deklaration bis zur schließenden Klammer ihres Blocks verwendet werden. Ein Parameter ist im gesamten Rumpf seiner Methode verfügbar. Ein in for (int i = 0; i < 3; i++) deklarierter Zähler gehört zu dieser Schleife; i kann danach nicht gelesen werden.

Um ein Ergebnis nach einer Schleife zu behalten, deklariere es vor der Schleife:

int sum = 0;
for (int i = 1; i <= 5; i++) {
    sum += i;
}
System.out.println(sum);

Durch die Additionen nimmt sum nacheinander die Werte 1, 3, 6, 10 und 15 an. Die abschließende Ausgabe kann sum lesen, weil der umgebende Block noch nicht beendet ist. i wird nur für die Schleife benötigt und bleibt innerhalb ihres Gültigkeitsbereichs.

Wenn du int sum = 0; in den Schleifenrumpf verschiebst, entsteht bei jedem Durchlauf ein neues sum. Jedes beginnt bei null und verschwindet am Ende dieses Durchlaufs. Es kann weder eine laufende Summe speichern noch nach der Schleife ausgegeben werden.

Prüfe Namen und Anfangswerte getrennt

Zwei lokale Variablen mit demselben Namen dürfen innerhalb einer Methode keine überlappenden Gültigkeitsbereiche haben. Eine Methode mit einem Parameter x kann keine weitere lokale Variable x deklarieren; eine Schleife, die i deklariert, kann in ihrem Rumpf kein weiteres i deklarieren. Benenne die zweite Variable um oder verwende die vorhandene.

Zwei aufeinanderfolgende Schleifen dürfen jeweils int i deklarieren. Der Gültigkeitsbereich der ersten Schleife ist vor der zweiten Deklaration beendet. Die geschweiften Klammern, nicht die ganze Datei, bestimmen diese Wiederverwendung.

Auch ein zulässiger Name braucht einen Wert, bevor er gelesen wird. int total; total++; schlägt fehl, weil ++ den alten Wert lesen muss und eine lokale Variable keinen automatischen Anfangswert erhält. Verwende int total = 0; für eine laufende Summe.

Halte eine lokale Variable im kleinsten Block, der sie benötigt. Benötigt eine Methode Informationen von ihrem Aufrufer, mache diese Informationen zu einem Parameter. Benötigt der Aufrufer ein Ergebnis, gib es zurück. Dann zeigen Kopf und Rumpf der Methode, woher ihre Daten stammen.

Java übergibt Argumente als Wert. Zu Beginn eines Aufrufs erhält jeder Parameter eine Kopie des Werts seines Arguments. Eine Zuweisung an den Parameter ändert diese lokale Variable.

Verfolge die Kopie getrennt

public static void main(String[] args) {
    int score = 10;
    addBonus(score);
    System.out.println(score);
}

public static void addBonus(int score) {
    score = score + 5;
    System.out.println(score);
}

Es gibt zwei Variablen namens score. Verfolge ihre Werte zu jedem Zeitpunkt:

Die Hilfsmethode gibt 15 aus, dann gibt main den Wert 10 aus. Ein gemeinsamer Name bedeutet nicht, dass die beiden Variablen denselben Speicherplatz nutzen. Eine Umbenennung des Parameters würde dieses Verhalten nicht ändern.

Gib den neuen Wert zurück und speichere ihn

public static int addBonus(int score) {
    return score + 5;
}

Schreibe bei dieser Version score = addBonus(score);. Java kopiert den alten Wert in den Parameter, berechnet 15, gibt diesen Wert zurück und weist ihn der Variablen des Aufrufers zu. Die Zuweisung beim Aufrufer ist der Schritt, der diese Variable ändert.

Ein Ergebnis kann auch an anderer Stelle gespeichert werden. Multipliziert triple(int n) sein lokales n mit 3 und gibt es zurück, bleibt bei int a = 4; int b = triple(a); der Wert von a gleich 4 und b erhält den Wert 12. Die Ausgabe von a + " " + b zeigt „4 12“.

Wende dieselbe Regel auf String-Referenzen an

Eine String-Variable enthält eine Referenz auf ein String-Objekt. Java kopiert diese Referenz in einen String-Parameter:

public static void exclaim(String text) {
    text = text + "!";
}

Verweist word beim Aufrufer auf „hi“, verweist word nach exclaim(word); weiterhin auf „hi“. Die Konkatenation erzeugt einen neuen String und die Zuweisung ändert nur, worauf der Parameter verweist. Der vorhandene Inhalt von Strings kann nicht geändert werden.

Um den neuen Text zu behalten, gib text + "!" aus einer String-Methode wie exclaimed zurück und schreibe dann word = exclaimed(word);.

Bei veränderlichen Objekten wie Listen kann eine kopierte Referenz weiterhin auf dasselbe Objekt zeigen. Eine Methode kann den Inhalt dieses Objekts über die kopierte Referenz ändern. Eine Neuzuweisung an den Parameter kann weiterhin nicht bewirken, dass die Variable des Aufrufers auf ein anderes Objekt verweist. Sowohl für kopierte Referenzen als auch für kopierte Zahlen gilt die Wertübergabe.

Du darfst einem Parameter einen neuen Wert zuweisen, aber eine separate lokale Variable wie result kann eine längere Berechnung leichter lesbar machen: Sie hält die ursprüngliche Eingabe verfügbar und zeigt zugleich, welcher Wert zurückgegeben wird.

Der Aufrufstapel erfasst Aufrufe, die begonnen haben, aber noch nicht beendet sind. Jeder Aufruf erhält einen Stapelrahmen mit seinen Parametern, lokalen Variablen und der Stelle, an der sein Aufrufer fortsetzt.

Lege einen Rahmen auf den Stapel und entferne ihn nach der Ausführung

Der Stapel folgt dem LIFO-Prinzip: Was zuletzt hineinkommt, wird zuerst entfernt. Der neueste Aufruf liegt oben und wird ausgeführt, während sein Aufrufer darunter wartet. Wenn er zurückkehrt, entfernt Java seinen Rahmen und setzt beim Aufrufer fort.

public static void main(String[] args) {
    int total = totalSeconds(2, 30);
    System.out.println(total);
}

public static int totalSeconds(int minutes, int seconds) {
    int fromMinutes = toSeconds(minutes);
    return fromMinutes + seconds;
}

public static int toSeconds(int minutes) {
    return minutes * 60;
}

Verfolge die noch nicht abgeschlossenen Aufgaben:

1. main beginnt und ruft totalSeconds(2, 30) auf. Die Zuweisung an total muss warten.
2. Der neue Rahmen enthält minutes = 2 und seconds = 30. Die Methode ruft toSeconds(minutes) auf und wartet auf fromMinutes.
3. toSeconds erhält ein eigenes minutes = 2. Die Methode gibt 120 zurück und ihr Rahmen wird entfernt.
4. totalSeconds speichert fromMinutes = 120, addiert 30 und gibt 150 zurück. Sein Rahmen wird entfernt.
5. main speichert total = 150 und gibt 150 aus.

An der tiefsten Stelle liegen die Rahmen von unten nach oben in der Reihenfolge main, totalSeconds und toSeconds. Beide Hilfsmethoden haben einen Parameter namens minutes, aber diese Parameter liegen in verschiedenen Rahmen. Die lokalen Variablen des wartenden Aufrufers werden für die Methode darüber nicht sichtbar.

Ein späterer Aufruf erhält einen neuen Rahmen. Ein lokaler Zähler merkt sich seinen vorherigen Wert nicht, nachdem sein Aufruf beendet wurde; der Rückgabewert kann ein Ergebnis zurückübermitteln.

Lies einen Stacktrace vom Fehler nach außen

Bei einer unbehandelten Ausnahme wird ein Stacktrace ausgegeben, der zeigt, wo der Fehler auftrat und welche Aufrufe dorthin führten. Hier ist eine vollständige Datei:

public class Main {
    public static void main(String[] args) {
        report(300, 0);
    }

    public static void report(int meters, int minutes) {
        int speed = perMinute(meters, minutes);
        System.out.println(speed + " m per minute");
    }

    public static int perMinute(int meters, int minutes) {
        return meters / minutes;
    }
}

Die erste Ausgabezeile lautet Exception in thread "main" java.lang.ArithmeticException: / by zero. Die Rahmen darunter sind:

at Main.perMinute(Main.java:12)
at Main.report(Main.java:7)
at Main.main(Main.java:3)

Der oberste Rahmen weist auf die Ganzzahldivision durch null hin. Die nächsten beiden zeigen die Aufrufe, die dorthin führten. Die Zeilennummern gehören genau zu diesem Aufbau der Datei; wenn du eine Zeile hinzufügst, ändern sie sich.

Der Stapel hat begrenzten Platz. Eine Kette, die fortlaufend Aufrufe hinzufügt, ohne sie enden zu lassen, kann einen StackOverflowError verursachen. In der Stapelansicht eines Debuggers kannst du dieselbe Kette untersuchen, während das Programm an einem Haltepunkt angehalten ist, einschließlich der eigenen Variablen jedes wartenden Aufrufs.

Überladen gibt Methoden denselben Namen mit unterschiedlichen Parameterlisten. Das ist nützlich, wenn die Methoden dieselbe Aufgabe für eine unterschiedliche Anzahl oder unterschiedliche Typen von Eingaben erfüllen.

Vergleiche Signaturen

Für diese Methoden besteht eine Signatur aus dem Namen und den Parametertypen in ihrer Reihenfolge. Die Anzahl der Parameter ergibt sich aus dieser Liste.

public static int max(int a, int b) {
    if (a > b) {
        return a;
    }
    return b;
}

public static int max(int a, int b, int c) {
    return max(max(a, b), c);
}

public static double max(double a, double b) {
    if (a > b) {
        return a;
    }
    return b;
}

Die Signaturen lauten max(int, int), max(int, int, int) und max(double, double). max(3, 9) verwendet die erste und gibt 9 zurück. max(3, 9, 5) ruft die zweite auf: Der innere Aufruf mit zwei int-Werten gibt 9 zurück, dann vergleicht der äußere Aufruf mit zwei int-Werten 9 und 5 und gibt ebenfalls 9 zurück. max(2.5, 1.0) verwendet die double-Version und gibt 2.5 zurück.

Erkenne, welche Änderungen nicht zählen

Eine Änderung allein des Rückgabetyps erzeugt keine Überladung. Diese Köpfe stehen im Konflikt:

public static int area(int w, int h)
public static double area(int w, int h)

Beide haben die Signatur area(int, int). Java lehnt die doppelte Deklaration ab. Auch das Umbenennen der Parameter in width und height lässt die Signatur gleich: Aufrufer übergeben Werte nach Position, nicht nach Parameternamen.

Die Reihenfolge unterschiedlicher Typen zählt dagegen. describe(String s, int n) und describe(int n, String s) sind unterschiedliche Signaturen. Sie lassen sich zusammen kompilieren, aber ein Aufrufer muss sich eine leicht zu verwechselnde Reihenfolge merken; verwende ein solches Paar daher nur, wenn es dem Entwurf hilft.

Lass eine kürzere Überladung einen Standardwert liefern

Java bietet in Methodendeklarationen keine Standardwerte für Parameter. Eine kürzere Überladung kann eine längere mit einem festen Argument aufrufen:

public static void printLine(int length, char symbol) {
    for (int i = 0; i < length; i++) {
        System.out.print(symbol);
    }
    System.out.println();
}

public static void printLine(int length) {
    printLine(length, '-');
}

printLine(5, '*'); gibt ***** aus. printLine(4); führt die kürzere Methode aus, die die längere mit 4 und '-' aufruft und ---- ausgibt. Die Schleife steht an einer Stelle, sodass Änderungen an der Ausgabeaufgabe für beide Formen gelten.

Auch die Java-Bibliothek verwendet Überladungen. System.out.println akzeptiert über verschiedene Versionen einen int-, double-, char-, boolean- oder String-Wert. Math.abs und Math.max bieten Versionen für int, long, float und double an.

Gib dem gemeinsamen Namen eine einzige Bedeutung. Das Ausgeben eines Belegs und das Ausgeben eines Etiketts sind unterschiedliche Aufgaben; klare Namen wie printReceipt und printLabel sagen dem Aufrufer, welche Aufgabe ausgeführt wird.

Der Compiler wählt eine Überladung anhand der Anzahl und der Typen der Argumente. Ermittle diese Wahl, bevor du betrachtest, wie der Rückgabewert verwendet wird.

Beginne mit exakten Typübereinstimmungen

Angenommen, eine Klasse definiert show(int x) und show(double x). show(5) verwendet die int-Version, weil das Literal 5 ein int-Wert ist. show(5.0) verwendet die double-Version. Ein als 5.0 geschriebener ganzzahliger Wert ist weiterhin ein double-Ausdruck.

Vergleiche bei einem Aufruf mit mehreren Argumenten den Typ an jeder Position. Ein Kandidat mit der falschen Anzahl von Argumenten kann nicht passen.

Erlaube bei Bedarf eine erweiternde Typumwandlung

Existiert nur show(double x), ist show(5) gültig: Der int-Wert wird zu 5.0 erweitert. Zu den möglichen erweiternden Umwandlungen primitiver Typen gehören:

byte → short → int → long → float → double
char → int → long → float → double

Bei show(long x) und show(double x) wählt ein int-Argument long. Das ist der spezifischere kompatible Parametertyp: Ein long-Wert kann zu double erweitert werden, ein double-Wert aber nicht zurück zu long.

Eine erweiternde Typumwandlung ist eine zulässige numerische Umwandlung; sie garantiert nicht, dass bei jeder solchen Umwandlung alle Stellen erhalten bleiben. Insbesondere kann bei der Umwandlung eines ausreichend großen long-Werts in double sein Wert gerundet werden. Die in den vorherigen Beispielen verwendete Umwandlung von int zu double erhält alle int-Werte exakt.

Ein char-Wert hat ebenfalls einen numerischen Wert. Bei letter(int code) und letter(String text) ruft letter('A') die int-Version mit 65 auf. Ein Zeichen wird nicht in einen String umgewandelt, damit es zu einem Parameter passt. Doppelte Anführungszeichen in "A" würden stattdessen ein String-Argument erzeugen.

Schließe implizite einengende Typumwandlungen aus

Gibt es nur show(int x), schlägt show(5.0) fehl. Java wandelt ein double-Argument nicht einengend um, nur weil sein Wert zufällig ganzzahlig ist. show((int) 5.0) übergibt nach einem expliziten Cast einen int-Wert.

Ebenso können Versionen von max für zwei und drei int-Werte max(1) nicht akzeptieren. Kein Kandidat hat die erforderliche Anzahl von Parametern, daher meldet der Compiler „no suitable method found“. Vergleiche die Kandidatenliste mit den übergebenen Argumenten.

Trenne die Auswahl der Überladung von der Ergebnisumwandlung

Betrachte int twice(int n) und double twice(double x). In double d = twice(3); wählt das Argument die int-Überladung. Dieser Aufruf gibt 6 zurück, dann erweitert die Zuweisung den Wert zu 6.0. Die Zielvariable d wählt nicht die double-Überladung.

Erkenne einen mehrdeutigen Aufruf

public static void combine(int a, double b) { }
public static void combine(double a, int b) { }

combine(1, 2) passt zur ersten Version nach Erweiterung des zweiten Arguments und zur zweiten nach Erweiterung des ersten. Keine der beiden Signaturen ist über beide Positionen hinweg spezifischer. Java meldet „reference to combine is ambiguous“; es wählt nicht die zuerst geschriebene Definition.

combine(1, 2.0) passt nur zu (int, double), weil die andere Signatur eine einengende Umwandlung von 2.0 benötigen würde. Ein eindeutiger Argumenttyp oder eine bessere Auswahl an Überladungen beseitigt die Mehrdeutigkeit.

Problemzerlegung bedeutet, ein Problem in kleinere Aufgaben zu teilen und jede Aufgabe in einer eigenen Methode zu lösen. Wähle Aufgaben, deren Namen helfen, den Plan des Programms zu verstehen.

Trenne Berechnung und Ein- und Ausgabe

Ein Programm für eine Radtour benötigt eine Geschwindigkeitsberechnung und einen Bericht. Beide verwenden dieselben Daten, haben aber unterschiedliche Aufgaben:

public static double kilometersPerHour(double km, double hours) {
    return km / hours;
}

public static void printRideReport(double speed) {
    System.out.println("Speed: " + speed + " km/h");
}

Für eine Fahrt von 150 km in 2 Stunden gibt die Berechnung 75.0 zurück. Die Berichtsmethode erhält diesen Wert und zeigt ihn an. Ein Aufrufer verbindet die Schritte:

double speed = kilometersPerHour(150, 2);
printRideReport(speed);

Die Berechnung liest keine Tastatureingaben und gibt keinen Bericht aus. Ein anderes Programm kann sie verwenden, um Fahrten zu vergleichen oder Geschwindigkeiten zu speichern, ohne ihren Rumpf zu ändern. Um sie zu testen, rufe sie mit bekannten Eingaben auf und vergleiche die zurückgegebene Zahl mit der erwarteten.

Erkenne eine Methode mit zu vielen Aufgaben

Ein Name wie readAndCheckAndPrint deutet auf mehrere Tätigkeiten hin. Weitere Hinweise sind durch Kommentare gekennzeichnete Abschnitte, ein Rumpf, der länger als eine Bildschirmseite ist, und Gruppen von Variablen, die unabhängigen Zwecken dienen. Das sind Gründe, die Methode zu untersuchen, keine starren Grenzen für ihre Zeilenanzahl.

Teile an einer sinnvollen Stelle. Eingabecode kann einen Wert einlesen, eine boolesche Hilfsmethode kann ihn prüfen, eine Berechnung kann ein Ergebnis zurückgeben und eine Berichtsmethode kann es anzeigen. Dann liest sich main wie eine kurze Beschreibung, wie diese Aufgaben zusammenhängen.

Auf eine Aufgabe konzentrierte Methoden lassen sich einzeln leichter lesen, wiederverwenden und testen. Ändert sich das Format eines Berichts, bearbeite die Berichtsmethode. Ist eine Berechnung falsch, teste sie, ohne eine ganze Folge von Eingaben eintippen zu müssen.

Lass den Kopf den Datenfluss erklären

In kilometersPerHour(double km, double hours) nennt der Name das Ergebnis, die Parameternamen nennen die Größen und der Rückgabetyp double nennt die Art des Ergebnisses. Ein kurzer Javadoc-Kommentar kann die Bedeutung der Eingaben und des Ergebnisses ergänzen:

/**
 * Calculates a ride's average speed.
 * @param km distance in kilometers
 * @param hours elapsed time in hours, greater than zero
 * @return speed in kilometers per hour
 */

Setze diesen Kommentar direkt über den Methodenkopf. Ein nützlicher Kommentar ergänzt Informationen wie Einheiten oder eine Anforderung an die Eingabe; er muss nicht jede Zeile des Rumpfs beschreiben.

Eine Hilfsmethode, die nur ihre eigene Klasse benötigt, kann private static sein. private verhindert, dass andere Klassen sie aufrufen, während Code in derselben Klasse sie weiterhin verwenden kann. public static stellt die Hilfsmethode anderen Klassen zur Verfügung.

Auch wenn du jede offensichtliche Anweisung in eine eigene umhüllende Methode auslagerst, kann das den Plan verschleiern. Behalte eine Methode, wenn ihr Name für einen sinnvollen Schritt oder eine wiederverwendbare Berechnung steht. Eine Kette von Hilfsmethoden, die denselben Aufruf nur weiterreichen, schafft mehr Stellen zum Untersuchen, ohne mehr über die Aufgabe zu erklären.

Codeduplizierung wiederholt dieselbe Aufgabe an mehreren Stellen. Wenn sich nur die Eingabewerte unterscheiden, kann eine parametrisierte Methode die gemeinsame Arbeit zusammenhalten.

Finde die gemeinsame Berechnung

Angenommen, ein Programm summiert von 1 bis 10 und dann von 1 bis 50:

int total1 = 0;
for (int i = 1; i <= 10; i++) {
    total1 += i;
}
System.out.println("Sum 1 to 10: " + total1);
int total2 = 0;
for (int i = 1; i <= 50; i++) {
    total2 += i;
}
System.out.println("Sum 1 to 50: " + total2);

Beide Schleifen beginnen bei 1, addieren zu einer Summe und enden bei einer oberen Grenze. Nur diese Grenze ändert sich. Ein Parameter n kann sie an eine gemeinsame Berechnung übergeben.

Extrahiere die Methode

public static int sumUpTo(int n) {
    int total = 0;
    for (int i = 1; i <= n; i++) {
        total += i;
    }
    return total;
}

n ist die veränderliche Eingabe. total und i sind Arbeitsvariablen, die in die Hilfsmethode gehören. Der Aufrufer benötigt die fertige Summe, also gibt die Hilfsmethode einen int-Wert zurück.

Ersetze beide wiederholten Abschnitte:

System.out.println("Sum 1 to 10: " + sumUpTo(10));
System.out.println("Sum 1 to 50: " + sumUpTo(50));

sumUpTo(10) gibt 55 zurück und sumUpTo(50) gibt 1275 zurück. Die ausgegebenen Zeilen lauten wie zuvor „Sum 1 to 10: 55“ und „Sum 1 to 50: 1275“. Die Beschreibungen bleiben beim Aufrufer; die Schleife führt nur die Berechnung aus.

Prüfe die Extraktion in einer festen Reihenfolge

1. Markiere die Anweisungen, die die wiederholte Aufgabe erfüllen.
2. Bestimme jeden Wert, der sich zwischen den Kopien unterscheidet.
3. Mache diese Werte zu Parametern mit passenden Typen und gib jedes außerhalb benötigte Ergebnis zurück.
4. Ersetze jede Kopie durch einen Aufruf mit ihren ursprünglichen Eingaben.
5. Führe das Programm vorher und nachher mit denselben Eingaben aus und vergleiche das Verhalten.

Die Struktur von Code zu ändern und dabei sein Verhalten zu erhalten, heißt Refactoring. Bleibt eine ursprüngliche Kopie zurück, muss eine spätere Korrektur weiterhin an zwei Stellen vorgenommen werden. Verschiebst du eine Ausgabe in eine Schleife oder änderst einen Schleifenendpunkt, ändert sich das Verhalten, auch wenn der Code nun kürzer ist.

Haben zwei Unterschiede verschiedene Typen, verwende passende Parameter. Soll unterschiedlicher Text unterschiedlich oft wiederholt werden, bietet sich printRepeated(String text, int times) an; das Wort ist ein String und die Anzahl ein int-Wert.

Ähnlich aussehender Code erfüllt nicht immer dieselbe Aufgabe. Ein boolescher Parameter, der eine Methode zwischen unabhängigen Berechnungen umschaltet, kann ihre Aufrufe schwer verständlich machen. Gib unterschiedlichen Aufgaben unterschiedliche Namen. Extrahiere die wiederholte Operation nur, wenn sie beim Ändern ihrer Eingaben eine klare Bedeutung behält.

Der Top-down-Entwurf beginnt mit der gesamten Aufgabe und verfeinert sie zu kleineren Methodenaufrufen. Entscheide, was jeder Aufruf benötigt und zurückgibt, bevor du alle Einzelheiten ausarbeitest.

Plane die Schritte und Köpfe

Ein Programm für die wöchentliche Bewegung liest 7 Tagesdauern ein, addiert sie und gibt einen Bericht aus. Seine Hilfsmethoden lassen sich so planen:

• readMinutes(Scanner scanner, int day) gibt die gültige Minutenzahl eines Tages zurück.
• isValidMinutes(int minutes) beantwortet, ob die Eingabe zwischen 0 und 1440 liegt.
• formatDuration(int minutes) gibt Text mit vollen Stunden und verbleibenden Minuten zurück.
• averagePerDay(int total, int days) gibt einen Durchschnitt als double-Wert zurück.
• printSummary(int totalMinutes, int days) gibt den Bericht aus.

Derselbe Scanner wird an jeden Eingabeaufruf übergeben. Eine Hilfsmethode wie isValidMinutes muss selbst keine Eingabe lesen.

Verwende beim Entwickeln Stubs

Ein Stub hat seinen endgültigen Kopf, aber einen vorläufigen minimalen Rumpf, etwa return 0;. Er ermöglicht das Kompilieren des Programms, bevor eine Hilfsmethode implementiert ist. Ersetze einen Stub, kompiliere und prüfe diese Methode, bevor du den nächsten ersetzt. Ein kompilierbarer Stub ist weiterhin unvollendete Arbeit; seine feste Antwort kann keine echte Berechnung überprüfen.

Hier ist das vollständige Programm:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int total = 0;
        for (int day = 1; day <= 7; day++) {
            total += readMinutes(scanner, day);
        }
        printSummary(total, 7);
    }

    public static int readMinutes(Scanner scanner, int day) {
        System.out.println("Minutes for day " + day + ":");
        int minutes = scanner.nextInt();
        while (!isValidMinutes(minutes)) {
            System.out.println("Enter minutes from 0 to 1440:");
            minutes = scanner.nextInt();
        }
        return minutes;
    }

    public static boolean isValidMinutes(int minutes) {
        return minutes >= 0 && minutes <= 1440;
    }

    public static String formatDuration(int minutes) {
        return minutes / 60 + " h " + minutes % 60 + " min";
    }

    public static double averagePerDay(int total, int days) {
        return (double) total / days;
    }

    public static void printSummary(int totalMinutes, int days) {
        System.out.println("Total: " + formatDuration(totalMinutes));
        System.out.println("Daily average: "
            + averagePerDay(totalMinutes, days) + " min");
        if (totalMinutes >= 150) {
            System.out.println("Weekly goal reached");
        }
    }
}

Bei ganzzahligen Eingaben wiederholt readMinutes seine Wertebereichsprüfung, bis die Zahl gültig ist. Bei den täglichen Eingaben 30, 45, 0, 60, 90, 45 und 45 beträgt die Summe 315. Die Formatierung ergibt „5 h 15 min“, der Durchschnitt beträgt 45.0 Minuten und das Programm meldet, dass sein Wochenziel von 150 Minuten erreicht ist.

Prüfe kleine Methoden und ihre Grenzwerte

Rufe jede Berechnung mit bekannten Ergebnissen auf. formatDuration(0) sollte „0 h 0 min“ ergeben, 59 ergibt „0 h 59 min“, 60 ergibt „1 h 0 min“ und 135 ergibt „2 h 15 min“. Die Eingaben knapp unter und bei 60 prüfen den Wechsel von Minuten zu einer vollen Stunde.

Teste für isValidMinutes die Werte -1, 0, 1440 und 1441. Die erwarteten Ergebnisse sind false, true, true und false. Wenn du erwartete und tatsächliche Werte nebeneinander ausgibst, wird ein Fehler sichtbar. JUnit automatisiert diese Art von Prüfung.

Die Bottom-up-Entwicklung beginnt damit, kleine Hilfsmethoden zu schreiben und zu testen, und verbindet sie dann zu größeren Schritten. Du kannst nach dem Top-down-Prinzip planen und nach dem Bottom-up-Prinzip entwickeln: Lege zuerst den Datenfluss fest, beweise dann, dass die kleinen Berechnungen funktionieren, und prüfe anschließend das verbundene Programm.