Métodos, parámetros y retorno
Cuando un programa crece, concentrar todo dentro de main dificulta entenderlo y reutilizarlo. Un método agrupa instrucciones que realizan una operación concreta y le da un nombre.
En Java hablamos de métodos porque estas operaciones se declaran dentro de una clase. Java no tiene funciones libres fuera de clases. En este curso usaremos métodos static para llamarlos desde main sin entrar todavía en objetos.
Declarar y llamar a un método
public class Saludo {
public static void main(String[] args) {
mostrarSaludo();
mostrarSaludo();
}
public static void mostrarSaludo() {
System.out.println("¡Hola desde un método!");
}
}
La declaración indica:
public: lo mantenemos por simplicidad y coherencia en los ejemplos; los modificadores de acceso se estudiarán más adelante;static: permite llamarlo desde el métodomain, que también esstatic, sin crear un objeto;void: no devuelve un resultado;mostrarSaludo: nombre del método;(): no recibe datos.
Declararlo no lo ejecuta. Cada llamada mostrarSaludo(); hace que Java entre en el método, ejecute su cuerpo y vuelva al punto siguiente a la llamada.
Práctica inmediata
Crea mostrarSeparador, que imprima diez guiones, y llámalo antes y después de un mensaje.
public static void mostrarSeparador() {
System.out.println("----------");
}
Parámetros y argumentos
Un parámetro es una variable declarada por el método para recibir un dato. Un argumento es el valor concreto que enviamos al llamarlo.
public static void saludar(String nombre) {
System.out.println("Hola, " + nombre);
}
saludar("Ada");
saludar("Linus");
nombre es el parámetro; "Ada" y "Linus" son argumentos de llamadas distintas.
Podemos recibir varios datos:
public static void mostrarProducto(String nombre, double precio) {
System.out.println(nombre + ": " + precio + " euros");
}
El orden y los tipos de los argumentos deben coincidir:
mostrarProducto("Teclado", 29.95);
Devolver un resultado
Un método con tipo de retorno calcula un valor y lo entrega mediante return:
public static int sumar(int a, int b) {
int resultado = a + b;
return resultado;
}
La llamada se puede usar donde encaje un int:
int total = sumar(4, 7);
System.out.println(total); // 11
return termina el método. El resultado debe ser compatible con el tipo declarado.
Un método que responde una pregunta
public static boolean esMayorDeEdad(int edad) {
return edad >= 18;
}
if (esMayorDeEdad(20)) {
System.out.println("Acceso permitido");
}
El nombre expresa una pregunta y el resultado boolean permite usarla directamente como condición.
Cálculos con varios parámetros
public static double calcularPrecioFinal(double precio, double descuento) {
double importeDescuento = precio * descuento / 100;
return precio - importeDescuento;
}
double finalCamiseta = calcularPrecioFinal(25.0, 20.0);
System.out.println(finalCamiseta); // 20.0
Cada parámetro representa una parte del contrato: para calcular necesitamos precio y porcentaje.
Mini reto: minutos a horas
Escribe un método que reciba minutos y devuelva horas con decimales.
public static double convertirMinutosAHoras(int minutos) {
return minutos / 60.0;
}
Dividimos entre 60.0 para obtener una división decimal. 90 minutos producen 1.5 horas.
Componer métodos
Un método puede utilizar el resultado de otro:
public static boolean cabeEnUnaSesion(int minutosDisponibles, int minutosNecesarios) {
return convertirMinutosAHoras(minutosDisponibles)
>= convertirMinutosAHoras(minutosNecesarios);
}
La composición evita repetir conversiones y mantiene cada operación centrada en una responsabilidad.
Programa completo
public class PlanEstudio {
public static void main(String[] args) {
mostrarSaludo("Nuria");
int minutos = 150;
double horas = convertirMinutosAHoras(minutos);
System.out.println("Tiempo disponible: " + horas + " horas");
if (esTiempoSuficiente(minutos, 120)) {
System.out.println("Puedes completar la sesión");
} else {
System.out.println("Necesitas más tiempo");
}
}
public static void mostrarSaludo(String nombre) {
System.out.println("Hola, " + nombre);
}
public static double convertirMinutosAHoras(int minutos) {
return minutos / 60.0;
}
public static boolean esTiempoSuficiente(int disponible, int necesario) {
return disponible >= necesario;
}
}
main coordina; cada método resuelve una operación pequeña y comprobable.
Errores habituales
Olvidar return
public static int duplicar(int numero) {
int resultado = numero * 2;
}
No compila: el contrato promete un int, pero ninguna instrucción lo devuelve.
Devolver un tipo incompatible
public static int duplicar(int numero) {
return "doble";
}
El texto no puede ser el resultado de un método declarado como int.
Confundir parámetro y argumento
En sumar(int a, int b), a y b pertenecen a la declaración. En sumar(3, 5), 3 y 5 son los argumentos.
Llamar con datos incorrectos
sumar(3) carece del segundo argumento. sumar("3", "5") entrega textos donde se esperan enteros. Ambas llamadas fallan al compilar.
Escribir después de return
public static int duplicar(int numero) {
return numero * 2;
// System.out.println("Fin"); // sería código inalcanzable
}
Una vez ejecutado return, el método ha terminado.
Ejercicio: calcular un pedido
Crea un programa con estos métodos:
calcularSubtotal(double precio, int unidades);calcularDescuento(double subtotal, double porcentaje);calcularTotal(double subtotal, double descuento).
Para precio 12.5, tres unidades y descuento del 10 %, el subtotal debe ser 37.5, el descuento 3.75 y el total 33.75.
Solución razonada
public class Pedido {
public static void main(String[] args) {
double subtotal = calcularSubtotal(12.5, 3);
double descuento = calcularDescuento(subtotal, 10.0);
double total = calcularTotal(subtotal, descuento);
System.out.println("Subtotal: " + subtotal);
System.out.println("Descuento: " + descuento);
System.out.println("Total: " + total);
}
public static double calcularSubtotal(double precio, int unidades) {
return precio * unidades;
}
public static double calcularDescuento(double subtotal, double porcentaje) {
return subtotal * porcentaje / 100;
}
public static double calcularTotal(double subtotal, double descuento) {
return subtotal - descuento;
}
}
Los resultados viajan entre métodos sin repetir fórmulas. En la siguiente unidad veremos dónde existen sus variables y cómo Java distingue métodos con el mismo nombre.