Rekursion in Java
Schreibe eine Methode namens down, die ein int namens n nimmt. Wenn n 0 oder kleiner ist, stoppe mit einem nackten return;. Sonst drucke n, dann rufe down(n - 1) aus derselben Methode auf. Aus main rufe down(3); auf. Der Bildschirm soll drei Zeilen zeigen: 3, dann 2, dann 1. Die Methode ruft sich mit einer kleineren Zahl auf, bis der Stopp die Kette beendet. Genau dieser Selbstaufruf mit Stopp ist der Lehrstoff dieser Seite.
Eine Methode, die sich selbst aufruft
Auf der Seite zum Gültigkeitsbereich lief mark einmal und war fertig. Hier läuft down, startet dann ein weiteres down mit einem neuen Argument, bevor der erste Aufruf ganz zu Ende ist. Jeder Aufruf hat sein eigenes n. Die Kette endet erst, wenn ein Aufruf den Stopp trifft.
Lege eine kleine Programmdatei namens Ladder.java an. Die public class in der ersten Zeile muss zum Dateinamen passen: public class Ladder. Lass keinen älteren Gate- oder Sign-Klassennamen in dieser Datei; der Compiler erwartet, dass Klassenname und Dateiname übereinstimmen.
Außerhalb von main, aber noch innerhalb der Klassenklammern, schreibe static void down(int n). Behalte auf dieser Seite void: jeder Schritt druckt, und nichts muss über ein typisiertes return zurückkommen. Der Stopp nutzt return; ohne Wert — das beendet nur diesen Aufruf. Speichere die Datei vor dem Kompilieren. Das vollständige erste Programm steht in der nächsten Box.
Ladder.java mit down
Das ist die Version, die du zuerst kompilierst. main hält einen Aufruf. down hält den Stopp, den Druck und den Selbstaufruf.
public class Ladder {
public static void main(String[] args) {
down(3);
}
static void down(int n) {
if (n <= 0) {
return;
}
System.out.println(n);
down(n - 1);
}
}
Aus dem Ordner, der Ladder.java enthält, führe javac Ladder.java aus. Wenn runde Klammern, geschweifte Klammern und Semikolons passen, schreibt javac keine eigene Zeile. Dann führe java Ladder aus — nicht java Ladder.java. Lass die Endung .java beim zweiten Befehl weg. Dieselben zwei Befehle funktionieren unter Windows und macOS. Das Programm soll drei Zeilen drucken und stoppen: 3, dann 2, dann 1. Es soll dich nicht tippen lassen. Wenn das Terminal auf Tastatureingabe wartet, steckt noch ein nextLine-Aufruf aus einer älteren Übung in der Datei. Lösche diesen Aufruf und behalte down(3); plus die Methode down oben.
Gehe den Lauf einmal der Reihe nach durch. Java startet bei main. Der Aufruf down(3) startet mit n gleich 3. Das ist größer als 0, also druckt die Methode 3 und ruft dann down(2) auf. Der zweite Aufruf druckt 2 und ruft down(1) auf. Der dritte Aufruf druckt 1 und ruft down(0) auf. Der Aufruf mit 0 trifft n <= 0 und kehrt ohne Druck zurück. Die Kette endet. Der Bildschirm behält die drei gedruckten Zeilen.
Jeder dieser Aufrufe ist ein eigener Durchlauf durch denselben Methodentext. Der erste Durchlauf hat nach dem Start von down(2) noch Arbeit — nämlich fertig zu werden, nachdem der innere Aufruf zurückkehrt. Du schreibst keine vier verschiedenen Methodennamen. Du schreibst eine Methode und lässt das kleinere Argument den Fortschritt zum Stopp tragen.
Wenn du den Start auf down(2); änderst, soll der Bildschirm 2 dann 1 zeigen. Der Methodenkörper bleibt gleich; nur das erste Argument ändert sich, also ist die Kette kürzer. Ein Start mit down(4); soll vier Zeilen zeigen: 4, 3, 2, 1. Wieder bleibt der Körper gleich; nur main wählt den ersten Wert.
Setze den Stopp zuerst
Der Stopp muss vor dem Druck und vor dem Selbstaufruf geprüft werden. Wenn du zuerst druckst und n nie testest, oder wenn du immer down(n) mit demselben Wert aufrufst, endet das Programm nicht. Behalte den Block if (n <= 0) oben in der Methode auf dieser Anfängerform.
public class Ladder {
public static void main(String[] args) {
down(2);
}
static void down(int n) {
if (n <= 0) {
return;
}
System.out.println(n);
down(n - 1);
}
}
Kompiliere und führe erneut aus: javac Ladder.java, dann java Ladder. Der Bildschirm zeigt 2 dann 1. Der Stopp beendet die Kette weiterhin, wenn n 0 erreicht. down(n) statt down(n - 1) schickt dieselbe Zahl immer wieder. Dann kann das Programm laufen, bis das System es stoppt. Das kleinere Argument gehört zur Idee: jeder Aufruf muss sich auf den Stopp zubewegen.
Denk an den Stopp als Ausgangstür. Der Druck ist die Arbeit dieses Schritts. Der Selbstaufruf ist der nächste Schritt. Fehlt die Tür, öffnet jeder Schritt einen weiteren ohne Ende. Nutzt der nächste Schritt dasselbe n, gehst du nie zur Tür. Beide Fehler sehen im Quelltext anders aus, aber beide enden auf dieser Anfängerform nicht sauber.
Aufrufkette neben dem Bildschirm
Lies einen Startaufruf neben den Zeilen, die er erzeugt. Jede Zeile ist ein Besuch bei down, der noch druckt.
📊 down call chain for down(3)
| Aufruf | Wert von n | Bildschirmzeile |
|---|---|---|
erstes down(3) |
3 |
3 |
dann down(2) |
2 |
2 |
dann down(1) |
1 |
1 |
dann down(0) |
0 |
(keine Zeile — Stopp) |
Ein häufiger Fehler ist, den Stopp wegzulassen. Dann druckt jeder Aufruf und ruft erneut auf — ohne Ende. Ein anderer Fehler ist, nach dem rekursiven Aufruf statt davor zu drucken. Auf dieser Seite kommt der Druck zuerst, also zählt der Bildschirm abwärts. Wenn du println unter down(n - 1) schiebst, ändert sich die Reihenfolge — behalte den Druck über dem Selbstaufruf für den Countdown hier.
Der Gültigkeitsbereich der vorherigen Seite spielt noch eine kleine Rolle: Das n jedes Aufrufs ist der Parameter dieses Aufrufs. Das n des äußeren Aufrufs überschreibt sich nicht, wenn der innere läuft. Der innere Aufruf hat ein eigenes n. Wenn der innere zurückkehrt, macht der äußere nach dem Selbstaufruf weiter — und auf dieser Seite ist das einfach das Ende der Methode.
Eine übrig gebliebene Gate-Demo mit mark(4) kann in derselben Datei sitzen und den Bildschirm verwirren, wenn main noch mark aufruft. Räume main auf down(3); oder down(2);, während du diese Seite lernst. Verschachtele down nicht in den Klammern von main. Methoden sitzen in der Klasse neben main.
System.out.println("down"); in main druckt das Wort down. Es startet die Kette nicht. Behalte down(3);, wenn du die drei Countdown-Zeilen willst.
Noch eine Form: der Stopp druckt nichts
Du hast gesehen, dass der Aufruf mit 0 still zurückkehrt. Du kannst auch mit dem Startwert 1 üben. Der Bildschirm soll eine Zeile zeigen: 1. Der nächste Aufruf ist dann down(0), der stoppt.
public class Ladder {
public static void main(String[] args) {
down(1);
}
static void down(int n) {
if (n <= 0) {
return;
}
System.out.println(n);
down(n - 1);
}
}
Nach javac Ladder.java und java Ladder zeigt der Bildschirm eine Zeile: 1. Derselbe Methodenkörper deckt down(3), down(2) und down(1) ab. Nur das erste Argument in main ändert sich. Das reicht für diese Anfängerseite. Tiefere Ideen wie das Zurückgeben einer Summe aus Rekursion warten auf spätere Kurse; hier sind Selbstaufruf, kleineres Argument und Stopp das Ziel.
Wenn der Bildschirm gar nichts zeigt, prüfe, ob main noch etwas anderes aufruft, oder ob der Stopptest falsch ist — zum Beispiel würde if (n >= 0) bei positivem Start vor jedem Druck stoppen. Behalte n <= 0 als ruhigen Ausgang und einen positiven Starter in main, damit mindestens eine Zeile erscheinen kann.
Vor classes
Du kannst down(int n) schreiben, bei n 0 oder weniger stoppen, n drucken und dann down(n - 1) aufrufen. Aus main startet ein Aufruf die ganze Kette. Der Bildschirm zeigt die Countdown-Zeilen. Eine Methode, die sich nie auf den Stopp zubewegt, endet nicht. Die nächste Seite ist classes; dort beginnst du Typen mit Feldern jenseits dieser static-Methodenseiten.
🧠 Testen Sie Ihr Wissen
Testen Sie Ihr Wissen
Fordern Sie sich mit diesem interaktiven Quiz heraus und sehen Sie, wie gut Sie das Thema verstehen
📝 Anweisungen
- Lesen Sie jede Frage sorgfältig
- Wählen Sie die beste Antwort für jede Frage
- Sie können das Quiz so oft wiederholen, wie Sie möchten
- Ihr Fortschritt wird oben angezeigt