Métodos y descomposición de programas en Java

Un método es un bloque de sentencias con nombre que realiza una tarea. Definir un método hace que esa tarea esté disponible; llamarlo hace que se ejecute.

Lee la cabecera y el cuerpo

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

La primera línea es la cabecera. Lee sus partes de izquierda a derecha:

• public permite que el código de otras clases llame al método.
• static hace que el método pertenezca a la clase. No se necesita un objeto para llamarlo.
• void indica que el método no devuelve ningún valor.
• printLine da nombre a la tarea.
• () es la lista vacía de parámetros: este método no necesita datos de entrada.

Las llaves encierran el cuerpo, las sentencias que se ejecutan al hacer una llamada. No hay punto y coma entre esta cabecera y su llave de apertura.

Coloca la definición en la clase

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 y printLine son métodos independientes dentro de Main. La llave de cierre de main aparece antes de la definición de printLine. No se puede definir un método dentro de otro; una llave mal colocada puede producir «illegal start of expression».

Las definiciones pueden aparecer en cualquier orden. Mover printLine encima de main no cambia cuándo se ejecuta. Un método al que nunca se llama no se ejecuta solo porque su definición aparezca en el archivo.

Sigue una llamada y el regreso a quien llama

La llamada printLine(); consta del nombre, los paréntesis y un punto y coma, porque la llamada es una sentencia independiente. La ejecución comienza en main:

1. Imprime «Start».
2. Entra en printLine, imprime diez guiones y después continúa tras la llamada.
3. Imprime «Middle».
4. Entra de nuevo en printLine e imprime otra vez diez guiones.

La salida es:

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

Ambas llamadas utilizan la misma definición. Cambiar la línea que imprime cambia los dos lugares donde se utiliza.

Nombra y llama a los métodos con precisión

Utiliza un verbo o una frase verbal en camelCase, empezando con minúscula: printReceipt, calculateAverage o isValidCode. Java distingue mayúsculas y minúsculas: PrintLine() no puede encontrar un método llamado printLine. Escribir printLine; también falla; los paréntesis forman parte de la llamada.

Para un método estático de otra clase, escribe primero el nombre de la clase. Math.max(3, 8) da 8, Math.abs(-4) da 4 y Math.sqrt(16.0) da 4.0. A tus propios métodos de la misma clase puedes llamarlos solo por su nombre.

Estos ejemplos utilizan la forma clásica basada en clases con public static void main(String[] args). Java 25 también admite archivos fuente compactos con void main() y sin una clase que los rodee. Mantén la forma clásica al ejecutar estos ejemplos; sus métodos auxiliares se declaran static. Los métodos de la biblioteca de Java a los que llamas, como System.out.println, no tienen por qué ser estáticos.

Un parámetro permite que un método maneje valores que cambian de una llamada a otra. Un argumento es el valor que se proporciona para ese parámetro cuando se llama al método.

Da un tipo y un nombre a cada dato de entrada

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

int count declara un parámetro. En printStars(3);, el argumento 3 se convierte en el valor inicial de count. El bucle se ejecuta tres veces, por lo que imprime ***, y después println() termina la línea. printStars(8); utiliza el mismo cuerpo con count igual a 8.

El tipo se escribe en la definición, no en la llamada. Escribe printStars(5);, no printStars(int 5);.

Evalúa los argumentos antes de entrar en el cuerpo

Un argumento puede ser un literal, una variable o una expresión:

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

Java evalúa primero n * 2. Pasa el valor resultante 8, por lo que el cuerpo comienza con count igual a 8. El nombre de la variable de quien llama no tiene que coincidir con el nombre del parámetro.

Relaciona varios parámetros por posición

Cada parámetro necesita su propio tipo. Un método para rectángulos puede comenzar con esta cabecera:

public static void printRectangle(int width, int height)

La llamada printRectangle(5, 2); da a width el valor 5 y a height el valor 2. Invertir los argumentos da un rectángulo de 2 de ancho y 5 de alto. Ambas llamadas compilan porque los dos argumentos son int; solo la figura que se pretende obtener permite saber qué orden es correcto. Escribir (int width, height) en la cabecera falla porque height no tiene un tipo declarado.

Los tipos diferentes facilitan la detección de algunos errores de orden:

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); imprime «ababab». printRepeated(3, "ab"); no puede corresponderse con un String seguido de un int. El número de argumentos también debe coincidir: printRectangle(5); deja un parámetro sin valor.

Comprueba los tipos numéricos compatibles

Java amplía automáticamente un int a double. Un método con los parámetros (double km, double hours) acepta los argumentos (150, 2), lo que le proporciona 150.0 y 2.0. Todo valor int puede representarse exactamente como double.

Java no reduce implícitamente un argumento double para ajustarlo a un parámetro int. printStars(2.9); falla porque convertirlo haría perder la parte fraccionaria. La conversión explícita de tipo en printStars((int) 2.9); produce 2, por lo que se imprimen dos estrellas. Utiliza una conversión explícita solo cuando quieras descartar esa parte.

Elige un parámetro para cada dato que necesite la tarea. Recibir texto y una cantidad permite utilizar printRepeated con datos del teclado, una llamada de prueba fija u otro método. Su cuerpo no tiene que decidir de dónde proceden esos valores.

Un valor de retorno es un resultado que un método envía a quien lo llamó. Una vez terminada la llamada, esta puede utilizarse como una expresión del tipo de ese resultado.

Declara qué se devuelve

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

int sustituye a void en la cabecera porque este método devuelve un entero. La sentencia return evalúa a + b y envía el valor al lugar de la llamada. Para sum(4, 7), ese valor es 11.

Quien llama decide qué sucede después:

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

La primera línea almacena 11; la segunda imprime 11; la tercera almacena 10. Un valor devuelto también puede utilizarse en una condición, como if (sum(a, b) > 10).

Un resultado int compatible puede ampliarse al devolverse desde un método double. Un resultado double no puede devolverse desde un método int sin una conversión explícita adecuada.

Calcula la expresión antes de convertir el resultado

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

Para average(3, 4), el numerador es 7. Dividir por el literal double 2.0 da 3.5. Si la expresión fuera (a + b) / 2, Java primero dividiría dos int y obtendría 3. Solo después ampliaría ese valor al 3.0 devuelto. Un tipo de retorno double no corrige una división entera ya realizada dentro del cuerpo.

Distingue entre devolver e imprimir

Una llamada void no puede proporcionar un valor en una asignación ni en otra llamada. Si printSum es void, int total = printSum(1, 2); falla aunque printSum imprima un número. Utiliza un método que devuelva un valor para los cálculos y deja que quien llama decida si lo imprime.

Devuelve texto y respuestas de sí o no

Los tipos de retorno también incluyen String y boolean. Un método de saludo puede devolver "Hello, " + name + "!", lo que da «Hello, Ana!» para el argumento "Ana". Un método isEven(int n) puede devolver n % 2 == 0.

Un método de formato convierte un número en texto reutilizable:

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

Para 135, la división entera da 2 horas completas y el resto da 15 minutos. El resultado es «2 h 15 min»; para 60, es «1 h 0 min».

Conserva o combina el resultado

Una llamada como sum(4, 7); compila, pero descarta su resultado. Si square(x) devuelve un valor nuevo, utiliza x = square(x); para almacenarlo en x.

Un resultado también puede convertirse inmediatamente en argumento. En Math.max(sum(1, 2), 4), sum(1, 2) da primero 3 y después Math.max(3, 4) da 4. Evalúa la llamada interna antes de utilizar su resultado en la externa.

Una sentencia return termina inmediatamente la llamada al método actual. Dentro de un condicional o un bucle, sigue saliendo de todo el método, no solo de ese bloque.

Da una respuesta a cada ruta

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

larger(9, 4) devuelve 9 desde dentro del if. Para larger(2, 6), se omite el cuerpo del if y el return final da 6. Entradas iguales como (5, 5) también llegan al return final, que da 5. No se necesita un else después del primer return porque esa ruta ya ha salido del método.

En un método ordinario que devuelve un valor, ninguna ruta posible puede llegar a la llave de cierre sin proporcionar un valor. Un método de signo que devuelve valores solo para entradas positivas y negativas deja el cero sin respuesta:

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

El return final completa el método. Dos sentencias if separadas, una que comprueba n > 0 y otra que comprueba n <= 0, siguen necesitando un return final o una estructura if/else clara. La comprobación de retornos de Java no deduce que esas dos comparaciones cubren todos los enteros. Una sentencia situada directamente después de un return incondicional en el mismo bloque es inalcanzable y se rechaza.

Termina una búsqueda en el momento adecuado

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

Para (10, 20), el bucle descarta 10, 11, 12 y 13, y después devuelve 14. La llamada termina sin comprobar del 15 al 20. Para (15, 20), el bucle termina sin coincidencias, por lo que el return posterior devuelve -1, la señal acordada de «no encontrado».

Poner else { return -1; } dentro del bucle haría que terminara después del primer candidato que no cumple la condición. La búsqueda desde 10 indicaría entonces un fallo antes de llegar a 14. El retorno que indica el fallo debe ir después de haber probado todos los candidatos.

Devuelve la propia condición

Una comparación ya produce un booleano. Escribe return n % 2 == 0; en lugar de un if/else que devuelva true y false por separado. El nombre de un método booleano suele empezar con is o has, de modo que una llamada se lee de forma natural dentro de un if.

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

Esto devuelve true para 2024 y 2000, pero false para 1900 y 2023. Utiliza directamente if (isLeapYear(y)).

Sal anticipadamente de un método void

Un método void utiliza return; sin valor. Por ejemplo, printSquareRoot(double x) puede imprimir «No real square root» y retornar inmediatamente para una entrada negativa. Para otras entradas puede imprimir Math.sqrt(x), que da 1.5 para 2.25. Escribir return 5; en un método void falla porque su cabecera indica que no devuelve ningún valor.

El ámbito de una variable es la región del código donde puede utilizarse su nombre. Empieza por las llaves que rodean su declaración: un nombre local pertenece a un método o bloque concreto.

Las variables locales de quien llama permanecen allí

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

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

El price de main y el parámetro price de printDouble son variables independientes. El argumento proporciona el valor que necesita el método auxiliar, por lo que este imprime 40.

Eliminar el parámetro y llamar a printDouble() no permite que el método auxiliar lea la variable local price de main. Su cuerpo fallaría con «cannot find symbol». Llamar a un método desde otro no une sus ámbitos. Distintos métodos pueden utilizar cada uno el nombre count sin vincular sus variables.

Un bloque anidado crea un ámbito más pequeño

Una variable local puede utilizarse desde su declaración hasta la llave de cierre de su bloque. Un parámetro está disponible en todo el cuerpo de su método. Un contador declarado en for (int i = 0; i < 3; i++) pertenece a ese bucle; i no puede leerse después.

Para conservar un resultado después de un bucle, decláralo antes del bucle:

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

Las sumas hacen que sum pase por 1, 3, 6, 10 y 15. La impresión final puede leer sum porque el bloque que lo contiene no ha terminado. i solo se necesita para el bucle y permanece dentro de su ámbito.

Mover int sum = 0; al cuerpo del bucle crea un nuevo sum en cada pasada. Cada uno empieza en cero y desaparece al final de esa pasada. No puede mantener una suma acumulada ni imprimirse después del bucle.

Comprueba por separado los nombres y los valores iniciales

Dos variables locales con el mismo nombre no pueden tener ámbitos que se solapen dentro de un método. Un método con un parámetro x no puede declarar otra variable local x; un bucle que declara i no puede declarar otra i en su cuerpo. Cambia el nombre de la segunda variable o utiliza la existente.

Dos bucles consecutivos pueden declarar cada uno int i. El ámbito del primer bucle ha terminado antes de la segunda declaración. Las llaves, no el archivo completo, determinan esa reutilización.

Un nombre válido también necesita un valor antes de leerse. int total; total++; falla porque ++ debe leer el valor anterior y una variable local no recibe automáticamente un valor inicial. Utiliza int total = 0; para una suma acumulada.

Mantén una variable local en el bloque más pequeño que la necesite. Si un método necesita información de quien lo llama, convierte esa información en un parámetro. Si quien llama necesita un resultado, devuélvelo. Así, la cabecera y el cuerpo del método muestran de dónde proceden sus datos.

Java pasa los argumentos por valor. Al comienzo de una llamada, cada parámetro recibe una copia del valor de su argumento. Asignar un valor al parámetro cambia esa variable local.

Sigue la copia por separado

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

Hay dos variables llamadas score. Sigue sus valores en cada momento:

El método auxiliar imprime 15 y después main imprime 10. Compartir un nombre no hace que las dos variables compartan almacenamiento. Cambiar el nombre del parámetro no alteraría este comportamiento.

Devuelve el nuevo valor y almacénalo

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

Con esta versión, escribe score = addBonus(score);. Java copia el valor anterior en el parámetro, calcula 15, lo devuelve y lo asigna a la variable de quien llama. La asignación en quien llama es el paso que cambia esa variable.

Un resultado también puede almacenarse en otro lugar. Si triple(int n) multiplica su n local por 3 y lo devuelve, entonces int a = 4; int b = triple(a); deja a igual a 4 y da a b el valor 12. Imprimir a + " " + b muestra «4 12».

Aplica la misma regla a las referencias String

Una variable String contiene una referencia a un objeto String. Java copia esa referencia en un parámetro String:

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

Si word de quien llama se refiere a «hi», exclaim(word); deja word haciendo referencia a «hi». La concatenación crea un nuevo String y la asignación solo cambia aquello a lo que se refiere el parámetro. El contenido existente de las cadenas String no puede modificarse.

Para conservar el nuevo texto, devuelve text + "!" desde un método String como exclaimed y después escribe word = exclaimed(word);.

En el caso de objetos mutables, como las listas, una referencia copiada puede seguir apuntando al mismo objeto. Un método puede cambiar el contenido de ese objeto mediante la referencia copiada. Reasignar el parámetro sigue sin poder hacer que la variable de quien llama se refiera a otro objeto. Tanto la regla de la referencia copiada como la del número copiado son paso por valor.

Puedes reasignar un parámetro, pero una variable local independiente como result puede facilitar la lectura de un cálculo largo: mantiene disponible la entrada original y muestra qué valor se devolverá.

La pila de llamadas registra las llamadas que han comenzado pero aún no han terminado. Cada llamada recibe un marco de pila con sus parámetros, variables locales y el lugar donde continuará quien la llamó.

Añade un marco, termínalo y retíralo

La pila funciona según el principio último en entrar, primero en salir. La llamada más reciente está arriba y se ejecuta mientras quien la llamó espera debajo. Cuando retorna, Java retira su marco y reanuda la ejecución de quien llamó.

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

Sigue el trabajo pendiente:

1. main comienza y llama a totalSeconds(2, 30). Su asignación a total debe esperar.
2. El nuevo marco tiene minutes = 2 y seconds = 30. Llama a toSeconds(minutes) y espera el valor de fromMinutes.
3. toSeconds recibe su propio minutes = 2. Devuelve 120 y se retira su marco.
4. totalSeconds almacena fromMinutes = 120, suma 30 y devuelve 150. Se retira su marco.
5. main almacena total = 150 e imprime 150.

En el punto de mayor profundidad, los marcos de abajo arriba son main, totalSeconds y toSeconds. Ambos métodos auxiliares tienen un parámetro llamado minutes, pero esos parámetros ocupan marcos distintos. Las variables locales de quien llama y está esperando no se vuelven visibles para el método situado encima.

Una llamada posterior recibe un marco nuevo. Un contador local no recuerda su valor anterior después de que su llamada haya terminado; el valor de retorno es lo que puede llevar un resultado de vuelta.

Lee una traza de la pila desde el error hacia fuera

Una excepción no manejada imprime una traza de la pila que muestra dónde ocurrió el error y qué llamadas llevaron hasta allí. Este es un archivo completo:

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

La primera línea de salida es Exception in thread "main" java.lang.ArithmeticException: / by zero. Los marcos que aparecen debajo son:

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

El marco superior identifica la división entera por cero. Los dos siguientes localizan las llamadas que llevaron hasta ella. Los números de línea corresponden a esta disposición exacta del archivo; añadir una línea los cambia.

La pila tiene un espacio limitado. Una cadena que sigue añadiendo llamadas sin dejar que terminen puede provocar StackOverflowError. La vista de pila de un depurador te permite examinar la misma cadena mientras está pausada en un punto de interrupción, incluidas las variables independientes de cada llamada en espera.

La sobrecarga da a los métodos el mismo nombre con distintas listas de parámetros. Es útil cuando los métodos realizan la misma tarea para distintas cantidades o tipos de datos de entrada.

Compara las firmas

Para estos métodos, una firma consta del nombre y los tipos de parámetros en orden. El número de parámetros se desprende de esa lista.

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

Las firmas son max(int, int), max(int, int, int) y max(double, double). max(3, 9) devuelve 9 utilizando la primera. max(3, 9, 5) llama a la segunda: la llamada interna con dos int devuelve 9, después la llamada externa con dos int compara 9 y 5 y también devuelve 9. max(2.5, 1.0) utiliza la versión double y devuelve 2.5.

Identifica qué cambios no cuentan

Cambiar solo un tipo de retorno no crea una sobrecarga. Estas cabeceras entran en conflicto:

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

Ambas tienen la firma area(int, int). Java rechaza la declaración duplicada. Cambiar los nombres de los parámetros a width y height también deja la misma firma: quienes llaman proporcionan valores por posición, no por nombre de parámetro.

El orden de los distintos tipos sí cuenta. describe(String s, int n) y describe(int n, String s) son firmas distintas. Compilan juntas, pero quien llama tiene que recordar un orden que es fácil confundir, así que utiliza un par así solo cuando ayude al diseño.

Deja que una sobrecarga más corta proporcione un valor predeterminado

Java no proporciona valores predeterminados para los parámetros en las declaraciones de métodos. Una sobrecarga más corta puede llamar a otra más larga con un argumento fijo:

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, '*'); imprime *****. printLine(4); entra en el método más corto, que llama al más largo con 4 y '-', e imprime ----. El bucle está en un solo lugar, por lo que los cambios en la tarea de impresión se aplican a ambas formas.

La biblioteca de Java también utiliza sobrecargas. System.out.println acepta un int, un double, un char, un boolean o un String mediante distintas versiones. Math.abs y Math.max ofrecen versiones para int, long, float y double.

Mantén un solo significado para el nombre compartido. Imprimir un recibo e imprimir una etiqueta son tareas distintas; nombres claros como printReceipt y printLabel indican a quien llama qué tarea se realizará.

El compilador elige una sobrecarga según el número y los tipos de los argumentos. Determina esa elección antes de considerar cómo se utilizará el valor devuelto.

Empieza por las coincidencias exactas

Supón que una clase define show(int x) y show(double x). show(5) utiliza la versión int porque el literal 5 es un int. show(5.0) utiliza la versión double. Un valor entero escrito como 5.0 sigue siendo una expresión double.

Para una llamada con varios argumentos, compara el tipo en cada posición. Una candidata con un número incorrecto de argumentos no puede ser compatible.

Permite la ampliación cuando sea necesaria

Si solo existe show(double x), show(5) es válido: el int se amplía a 5.0. Las rutas de ampliación de tipos primitivos incluyen:

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

Si existen tanto show(long x) como show(double x), un argumento int selecciona long. Ese es el tipo de parámetro compatible más específico: un long puede ampliarse a double, mientras que un double no puede ampliarse de vuelta a long.

La ampliación es una conversión numérica permitida; no garantiza que cada conversión de este tipo conserve todos los dígitos. En particular, convertir un long suficientemente grande a double puede redondear su valor. La conversión de int a double utilizada en los ejemplos anteriores conserva exactamente todos los valores int.

Un char también tiene un valor numérico. Con letter(int code) y letter(String text), letter('A') llama a la versión int con 65. Un carácter no se convierte en String para ajustarse a un parámetro. Las comillas dobles en "A" crearían, en cambio, un argumento String.

Rechaza la reducción implícita

Si solo existe show(int x), show(5.0) falla. Java no reduce un argumento double solo porque su valor sea un número entero. show((int) 5.0) pasa un int después de una conversión explícita de tipo.

Del mismo modo, las versiones de max para dos y tres int no pueden aceptar max(1). Ninguna candidata tiene el número de parámetros necesario, por lo que el compilador indica «no suitable method found». Compara la lista de candidatas con los argumentos proporcionados.

Separa la selección de la sobrecarga de la conversión del resultado

Considera int twice(int n) y double twice(double x). En double d = twice(3);, el argumento selecciona la sobrecarga int. Esa llamada devuelve 6 y después la asignación lo amplía a 6.0. El destino d no selecciona la sobrecarga double.

Reconoce una llamada ambigua

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

combine(1, 2) es compatible con la primera tras ampliar su segundo argumento y con la segunda tras ampliar su primero. Ninguna firma es más específica en ambas posiciones. Java indica «reference to combine is ambiguous»; no elige la definición escrita primero.

combine(1, 2.0) solo es compatible con (int, double), porque la otra firma necesitaría una conversión de reducción de 2.0. Un tipo de argumento claro o un conjunto de sobrecargas mejor diseñado elimina la ambigüedad.

La descomposición consiste en dividir un problema en tareas más pequeñas y resolver cada tarea en su propio método. Elige tareas cuyos nombres ayuden a leer el plan del programa.

Separa el cálculo de la entrada y la salida

Un programa sobre un recorrido en bicicleta necesita calcular la velocidad y mostrar un informe. Ambos utilizan los mismos datos, pero realizan tareas distintas:

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

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

Para un recorrido de 150 km en 2 horas, el cálculo devuelve 75.0. El método que genera el informe recibe ese valor y lo muestra. Quien llama conecta los pasos:

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

El método de cálculo no lee datos del teclado ni imprime un informe. Otro programa puede utilizarlo para comparar recorridos o almacenar velocidades sin cambiar su cuerpo. Para probarlo, llámalo con datos de entrada conocidos y compara el número devuelto con el esperado.

Reconoce un método con demasiadas tareas

Un nombre como readAndCheckAndPrint sugiere varias acciones. Otras pistas son las secciones marcadas por comentarios, un cuerpo que ocupa más de una pantalla y grupos de variables que sirven para fines no relacionados. Son motivos para examinar el método, no límites mecánicos sobre el número de líneas que puede tener.

Divide el código en un punto que tenga sentido. El código de entrada puede obtener un valor, un método auxiliar booleano puede comprobarlo, un cálculo puede devolver un resultado y un método de informe puede mostrarlo. Así, main se lee como una breve descripción de cómo se conectan esas tareas.

Los métodos centrados en una tarea son más fáciles de leer por separado, reutilizar y probar. Si cambia el formato de un informe, edita el método que lo genera. Si un cálculo es incorrecto, prueba ese cálculo sin necesidad de introducir todos los datos de una sesión.

Deja que la cabecera explique el flujo de datos

En kilometersPerHour(double km, double hours), el nombre indica el resultado, los nombres de los parámetros indican las cantidades y el tipo de retorno double indica la clase de respuesta. Un breve comentario Javadoc puede añadir el significado de los datos de entrada y del resultado:

/**
 * 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
 */

Coloca ese comentario directamente encima de la cabecera del método. Un comentario útil añade información como las unidades o un requisito de entrada; no necesita narrar cada línea del cuerpo.

Un método auxiliar que solo necesita su propia clase puede ser private static. private impide que otras clases lo llamen, mientras que el código de la misma clase puede seguir utilizándolo. public static pone el método auxiliar a disposición de otras clases.

Dividir cada sentencia evidente en su propio método envoltorio también puede oscurecer el plan. Conserva un método cuando su nombre represente un paso significativo o un cálculo reutilizable. Una cadena de métodos auxiliares que simplemente transmiten la misma llamada añade lugares que examinar sin explicar mejor la tarea.

El código duplicado repite la misma tarea en más de un lugar. Cuando solo difieren los valores de entrada, un método con parámetros puede mantener unido el trabajo común.

Encuentra el cálculo común

Supón que un programa suma del 1 al 10 y después del 1 al 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);

Ambos bucles comienzan en 1, acumulan una suma y se detienen en un límite superior. Solo cambia ese límite. Un parámetro n puede llevarlo a un cálculo compartido.

Extrae el método

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

n es el dato de entrada que varía. total e i son variables de trabajo que pertenecen al método auxiliar. Quien llama necesita la suma final, por lo que el método auxiliar devuelve un int.

Sustituye las dos secciones repetidas:

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

sumUpTo(10) devuelve 55 y sumUpTo(50) devuelve 1275. Las líneas impresas son «Sum 1 to 10: 55» y «Sum 1 to 50: 1275», como antes. Las descripciones permanecen en quien llama; el bucle solo realiza el cálculo.

Comprueba la extracción en un orden fijo

1. Marca las sentencias que realizan la tarea repetida.
2. Identifica cada valor que difiere entre las copias.
3. Convierte esos valores en parámetros con tipos adecuados y devuelve cualquier resultado que se necesite fuera.
4. Sustituye cada copia por una llamada con sus datos de entrada originales.
5. Ejecuta los mismos datos de entrada antes y después, y compara el comportamiento.

Cambiar la estructura del código conservando su comportamiento es refactorización. Si dejas una copia original, una corrección posterior seguirá teniendo dos lugares que actualizar. Mover una impresión al interior de un bucle o cambiar un extremo del bucle modifica el comportamiento, aunque el código sea ahora más corto.

Cuando dos diferencias tienen tipos distintos, utiliza parámetros correspondientes. Repetir distintos textos un número diferente de veces sugiere printRepeated(String text, int times); la palabra es un String y la cantidad es un int.

El código que parece similar no siempre hace la misma tarea. Un parámetro booleano que alterna un método entre cálculos no relacionados puede hacer que sus llamadas sean difíciles de interpretar. Da nombres distintos a tareas distintas. Extrae la operación repetida solo cuando variar sus entradas conserve un significado claro.

El diseño descendente comienza con la tarea completa y la refina en llamadas a métodos más pequeños. Decide qué necesita y qué devuelve cada llamada antes de completar todos los detalles.

Planifica los pasos y las cabeceras

Un programa semanal de ejercicio lee 7 duraciones diarias, las suma e imprime un informe. Sus métodos auxiliares pueden planificarse así:

• readMinutes(Scanner scanner, int day) devuelve los minutos válidos de un día.
• isValidMinutes(int minutes) responde si la entrada está entre 0 y 1440.
• formatDuration(int minutes) devuelve texto con las horas completas y los minutos restantes.
• averagePerDay(int total, int days) devuelve una media double.
• printSummary(int totalMinutes, int days) imprime el informe.

Se pasa el mismo Scanner a cada llamada de entrada. Un método auxiliar como isValidMinutes no necesita leer datos por sí mismo.

Utiliza métodos provisionales durante la construcción

Un método provisional tiene su cabecera definitiva, pero un cuerpo mínimo temporal, como return 0;. Permite compilar el programa antes de implementar un método auxiliar. Sustituye un método provisional, compila y comprueba ese método antes de sustituir el siguiente. Un método provisional que compila sigue siendo trabajo pendiente; su respuesta fija no puede verificar un cálculo real.

Este es el programa completo:

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");
        }
    }
}

Para una entrada entera, readMinutes repite la comprobación del rango hasta que el número es válido. Con las entradas diarias 30, 45, 0, 60, 90, 45 y 45, el total es 315. El formato da «5 h 15 min», la media es 45.0 minutos y el programa indica que se alcanza su meta semanal de 150 minutos.

Comprueba los métodos pequeños y sus límites

Llama a cada método de cálculo con resultados conocidos. formatDuration(0) debe dar «0 h 0 min», 59 da «0 h 59 min», 60 da «1 h 0 min» y 135 da «2 h 15 min». Las entradas justo por debajo de 60 y en ese valor comprueban el cambio de minutos a una hora completa.

Para isValidMinutes, prueba -1, 0, 1440 y 1441. Los resultados esperados son false, true, true y false. Imprimir los valores esperados y reales uno al lado del otro hace visible un error. JUnit automatiza este tipo de comprobación.

El desarrollo ascendente comienza escribiendo y probando métodos auxiliares pequeños y después los une en pasos más grandes. Puedes planificar de forma descendente y construir de forma ascendente: establece primero el flujo de datos, demuestra que los cálculos pequeños funcionan y después comprueba el programa conectado.