Recursión en Java

Escribe un método llamado down que tome un int llamado n. Si n es 0 o menos, para con un return; vacío. Si no, imprime n y luego llama down(n - 1) desde el mismo método. Desde main llama down(3);. La pantalla debe mostrar tres líneas: 3, luego 2, luego 1. El método se llama a sí mismo con un número menor hasta que la parada termina la cadena. Esa autollamada con parada es lo que enseña esta página.

Un método que se llama a sí mismo

En la página de ámbito, mark corría una vez y terminaba. Aquí down corre y luego arranca otro down con un argumento nuevo antes de que la primera llamada termine del todo. Cada llamada tiene su propio n. La cadena solo termina cuando una llamada choca con la parada.
Crea un archivo de programa pequeño llamado Ladder.java. El public class de la primera línea debe coincidir con el nombre del archivo: public class Ladder. No dejes un nombre de clase antiguo Gate o Sign en este archivo; el compilador espera que el nombre de la clase y el del archivo coincidan.
Fuera de main, todavía dentro de las llaves de la clase, escribe static void down(int n). En esta página mantén void: cada paso imprime y nada debe volver con un return tipado. La parada usa return; sin valor — solo termina esta llamada. Guarda el archivo antes de compilar. El primer programa completo está en el siguiente cuadro.

Ladder.java con down

Esta es la versión que compilas primero. main tiene una llamada. down tiene la parada, la impresión y la autollamada.

Desde la carpeta que guarda Ladder.java, ejecuta javac Ladder.java. Cuando paréntesis, llaves y puntos y coma coinciden, javac no escribe una línea propia. Luego ejecuta java Ladder — no java Ladder.java. Quita la terminación .java del segundo comando. Los mismos dos comandos funcionan en Windows y en macOS. El programa debe imprimir tres líneas y parar: 3, luego 2, luego 1. No debe pedirte que escribas. Si la terminal espera entrada de teclado, aún queda una llamada nextLine de un ejercicio anterior. Bórrala y conserva down(3); más el método down de arriba.
Recorre la ejecución una vez en orden. Java empieza en main. La llamada down(3) entra con n igual a 3. Es mayor que 0, así que el método imprime 3 y luego llama down(2). La segunda llamada imprime 2 y llama down(1). La tercera imprime 1 y llama down(0). La llamada con 0 choca con n <= 0 y vuelve sin imprimir. La cadena termina. La pantalla conserva las tres líneas impresas.
Cada una de esas llamadas es un paso separado por el mismo texto del método. El primer paso aún tiene trabajo después de arrancar down(2): terminar cuando la llamada interior vuelva. No escribes cuatro nombres de método distintos. Escribes un método y dejas que el argumento menor lleve el progreso hacia la parada.
Si cambias el inicio a down(2);, la pantalla debe mostrar 2 luego 1. El cuerpo del método sigue igual; solo cambia el primer argumento, así que la cadena es más corta. Empezar con down(4); debe mostrar cuatro líneas: 4, 3, 2, 1. Otra vez el cuerpo no cambia; solo main elige el primer valor.

Pon la parada primero

La parada debe comprobarse antes de la impresión y antes de la autollamada. Si imprimes primero y nunca pruebas n, o si siempre llamas down(n) con el mismo valor, el programa no termina. Mantén el bloque if (n <= 0) arriba del método en esta forma de principiante.

Compila y ejecuta otra vez: javac Ladder.java, luego java Ladder. La pantalla muestra 2 luego 1. La parada sigue cerrando la cadena cuando n llega a 0. Escribir down(n) en lugar de down(n - 1) manda el mismo número una y otra vez. Entonces el programa puede correr hasta que el sistema lo detenga. El argumento menor forma parte de la idea: cada llamada debe avanzar hacia la parada.
Piensa la parada como la puerta de salida. La impresión es el trabajo de este paso. La autollamada es el siguiente paso. Si falta la puerta, cada paso abre otro sin fin. Si el siguiente paso usa el mismo n, nunca caminas hacia la puerta. Ambos errores se ven distintos en el código, pero ambos se niegan a terminar limpio en esta forma de principiante.

Cadena de llamadas junto a la pantalla

Lee una llamada inicial junto a las líneas que produce. Cada fila es una visita a down que aún imprime.

Un error frecuente es omitir la parada. Entonces cada llamada imprime y vuelve a llamar sin fin. Otro error es imprimir después de la llamada recursiva en vez de antes. En esta página la impresión va primero, así que la pantalla cuenta hacia abajo. Si mueves println debajo de down(n - 1), el orden de las líneas cambia — mantén la impresión encima de la autollamada para la cuenta atrás de aquí.
El ámbito de la página anterior aún importa un poco: el n de cada llamada es el parámetro de esa llamada. El n de la llamada exterior no se reescribe cuando corre la interior. La interior tiene un n aparte. Cuando la interior vuelve, la exterior sigue después de la autollamada — y en esta página eso es simplemente el final del método.
Una demo sobrante de Gate con mark(4) puede quedarse en el mismo archivo y confundir la pantalla si main aún llama mark. Deja main en down(3); o down(2); mientras aprendes esta página. No anides down dentro de las llaves de main. Los métodos van dentro de la clase, junto a main.
Escribir System.out.println("down"); en main imprime la palabra down. No arranca la cadena. Conserva down(3); cuando quieras las tres líneas de cuenta atrás.

Otra forma: la parada no imprime nada

Ya viste que la llamada con 0 vuelve en silencio. También puedes practicar con el valor inicial 1. La pantalla debe mostrar una sola línea: 1. Luego la siguiente llamada es down(0), que para.

Después de javac Ladder.java y java Ladder, la pantalla muestra una línea: 1. El mismo cuerpo cubre down(3), down(2) y down(1). Solo cambia el primer argumento en main. Eso basta para esta página de principiante. Ideas más profundas como devolver una suma desde la recursión esperan cursos posteriores; aquí la meta es la autollamada, el argumento menor y la parada.
Si la pantalla no muestra nada, comprueba si main aún llama otra cosa, o si la prueba de parada está mal — por ejemplo if (n >= 0) pararía antes de cualquier impresión al empezar con un n positivo. Mantén n <= 0 como salida silenciosa y un inicio positivo en main para que al menos aparezca una línea.

Antes de classes

Puedes escribir down(int n), parar cuando n sea 0 o menos, imprimir n y luego llamar down(n - 1). Desde main, una llamada arranca toda la cadena. La pantalla muestra las líneas de cuenta atrás. Un método que nunca avanza hacia la parada no termina. La página siguiente es classes; allí empiezas a construir tipos con campos más allá de estas páginas de métodos static.