Fundamentos de programación Tema 3
Funciones y métodos
Funciona en el IDE online. Todo lo de esta sección funciona en el IDE online: pulsa Pruébalo en cualquier ejemplo, o abre el IDE y escribe el tuyo. Sin instalar nada.
Una función es un trozo de código con nombre que puedes usar todas las veces que quieras, solo con escribir ese nombre. Es como una receta: se escribe una vez, y cada vez que quieres el plato, la sigues.
Sirven para tres cosas:
| Para… | Ejemplo |
|---|---|
| No repetir código | Si saludas en cinco sitios del programa, escribes el saludo una vez y lo llamas cinco veces |
| Dividir un problema grande en partes pequeñas | Un juego se puede repartir en pedirJugada(), comprobarGanador(), mostrarTablero()… |
| Leer mejor el código | if (esPar(numero)) se entiende a la primera |
Crear y usar una función#
Una función se escribe fuera del main, pero dentro de la clase (en Java 25, sin clase, simplemente fuera del main). Para usarla (se dice llamarla), se escribe su nombre con paréntesis:
public class Saludos {
static void saludar() {
System.out.println("¡Hola! Bienvenido a Vericode");
}
public static void main(String[] args) {
saludar();
saludar();
}
}void saludar() {
IO.println("¡Hola! Bienvenido a Vericode");
}
void main() {
saludar();
saludar();
}El programa imprime el saludo dos veces. Las partes de static void saludar() son:
| Parte | Qué significa |
|---|---|
static | Por ahora, ponlo siempre (en Java 21). Lo entenderás en el tema de objetos. En Java 25, con void main(), no hace falta |
void | La función no devuelve ningún resultado: solo hace algo |
saludar | El nombre. Suele ser un verbo, y se escribe como las variables: calcularMedia, mostrarMenu |
() | Aquí van los datos que recibe la función (en este caso, ninguno) |
{ … } | El código que se ejecuta cada vez que se llama |
Parámetros: darle datos a la función#
Entre los paréntesis se ponen los parámetros: variables que la función recibe desde fuera cada vez que se la llama.
static void saludar(String nombre) {
System.out.println("¡Hola, " + nombre + "!");
}
// Dentro del main:
saludar("Ana"); // ¡Hola, Ana!
saludar("Hugo"); // ¡Hola, Hugo!Puede recibir varios, separados por comas, cada uno con su tipo:
static void repetir(String texto, int veces) {
for (int i = 0; i < veces; i++) {
System.out.println(texto);
}
}
// Dentro del main:
repetir("Java mola", 3);Importante
Al llamar a la función hay que darle los datos en el mismo orden y del mismo tipo que los parámetros. repetir(3, "Java mola") da error: primero va el texto y después el número.
Devolver un resultado: return#
Muchas funciones calculan algo y lo devuelven. En lugar de void se pone el tipo de lo que devuelve, y dentro, return con el valor:
static int doble(int n) {
return n * 2;
}
// Dentro del main:
int resultado = doble(5); // resultado vale 10
System.out.println(doble(7)); // 14return termina la función en ese momento: lo que haya después ya no se ejecuta.
| Tipo de la función | Qué devuelve | Ejemplo | Cómo se usa |
|---|---|---|---|
void | Nada | static void saludar() | saludar(); |
int | Un entero | static int doble(int n) | int d = doble(5); |
double | Un decimal | static double media(int a, int b) | double m = media(4, 7); |
boolean | true o false | static boolean esPar(int n) | if (esPar(8)) { … } |
String | Un texto | static String saludo(String nombre) | String s = saludo("Ana"); |
Las que devuelven boolean quedan muy claras dentro de un if:
static boolean esPar(int n) {
return n % 2 == 0;
}
// Dentro del main:
if (esPar(8)) {
System.out.println("Es par");
}¿Función, procedimiento o método?#
Vas a oír los tres nombres. Son casi lo mismo:
| Nombre | Qué es | Ejemplo |
|---|---|---|
| Función | Calcula algo y lo devuelve con return | static int doble(int n) |
| Procedimiento | Hace algo, pero no devuelve nada (void) | static void saludar() |
| Método | Así se llaman las dos en Java, porque siempre están dentro de una clase | doble, saludar, y también println o parseInt |
Variables locales#
Una variable creada dentro de una función solo existe dentro de ella: al terminar la función, desaparece. Por eso dos funciones distintas pueden tener variables con el mismo nombre sin estorbarse.
public class Contador {
static void contar() {
int total = 10; // solo existe dentro de contar()
System.out.println(total);
}
public static void main(String[] args) {
contar();
// System.out.println(total); ← error: aquí total no existe
}
}Si main necesita un dato que calcula otra función, la forma correcta es que la función lo devuelva con return.
Paso de parámetros: la función recibe una copia#
Cuando llamas a una función, cada parámetro recibe una copia del dato que le pasas. Si la función cambia su copia, la variable de quien llama no se entera:
static void subir(int n) {
n = n + 10; // cambia la copia
System.out.println("Dentro: " + n);
}
// Dentro del main:
int puntos = 5;
subir(puntos); // Dentro: 15
System.out.println("Fuera: " + puntos); // Fuera: 5Con un array pasa algo distinto. La variable de un array no guarda los números: guarda dónde está el array en la memoria (una referencia). Lo que se copia es esa dirección, así que la función trabaja con el mismo array y sus cambios sí se ven fuera. Por eso se suele decir que los arrays se pasan por referencia:
static void ponerACero(int[] v) {
for (int i = 0; i < v.length; i++) {
v[i] = 0; // cambia el array de quien llama
}
}
// Dentro del main:
int[] notas = {7, 4, 9};
ponerACero(notas);
System.out.println(notas[0]); // 0| Lo que se pasa | Qué recibe la función | ¿Se ven fuera sus cambios? |
|---|---|---|
Un int, double, char, boolean… | Una copia del valor | No |
| Un array | Una copia de la referencia: el mismo array | Sí, los de sus posiciones |
Un String | Una copia de la referencia, pero un texto no se puede cambiar | No |
Consejo
Si quieres que una función calcule un dato nuevo para main, lo claro es que lo devuelva con return. Cambiar un array que te pasan está bien cuando ese es justo el trabajo de la función, como ordenarlo o rellenarlo.
Sobrecarga: varias funciones con el mismo nombre#
Puede haber varias funciones con el mismo nombre, siempre que sus parámetros sean distintos: en número, en tipo o en orden. Java elige cuál ejecutar mirando los datos de la llamada. Es lo que se llama sobrecarga:
static int sumar(int a, int b) {
return a + b;
}
static int sumar(int a, int b, int c) {
return a + b + c;
}
static double sumar(double a, double b) {
return a + b;
}
// Dentro del main:
System.out.println(sumar(2, 3)); // 5: la de dos int
System.out.println(sumar(2, 3, 4)); // 9: la de tres int
System.out.println(sumar(2.5, 1.5)); // 4.0: la de dos doubleLo que distingue a una de otra son los parámetros, no lo que devuelve: dos funciones sumar(int a, int b), una que devuelve int y otra double, dan error, porque al llamar a sumar(2, 3) Java no sabría cuál elegir.
Ya conoces una función sobrecargada: System.out.println escribe un int, un double, un String… porque hay una versión para cada tipo.
Documentar un método: Javadoc#
Un método que se va a usar mucho, o que va a usar otra persona, se documenta con un comentario Javadoc: empieza por /**, va justo encima del método y dice qué hace, qué recibe y qué devuelve, con unas etiquetas que empiezan por @:
/**
* Calcula el precio final de un producto, con el IVA incluido.
*
* @param precio el precio sin IVA, en euros
* @param iva el IVA en tanto por uno: 0.21 es un 21 %
* @return el precio con el IVA sumado
*/
static double conIva(double precio, double iva) {
return precio + precio * iva;
}| Etiqueta | Qué dice |
|---|---|
@param nombre | Qué es ese parámetro. Una por parámetro, en el mismo orden |
@return | Qué devuelve. Un método void no la lleva |
@throws Excepción | Cuándo lanza esa excepción (la verás con las excepciones) |
No cambia nada al ejecutar, pero tiene dos ventajas: el IDE enseña ese texto al escribir el nombre del método o al pasar el ratón por encima, y la herramienta javadoc del JDK lo convierte en las páginas web de documentación del programa, las mismas que tiene Java para sus clases.
Recursividad: una función que se llama a sí misma#
Una función puede llamarse a sí misma. Se llama recursividad, y sirve cuando un problema se puede resolver con una versión más pequeña del mismo problema. El ejemplo clásico es el factorial: 5! = 5 · 4 · 3 · 2 · 1, que es lo mismo que 5 · 4!.
Toda función recursiva tiene dos partes:
| Parte | Qué es | En el factorial |
|---|---|---|
| Caso base | Cuándo se para: la respuesta se sabe sin volver a llamar | 0! y 1! valen 1 |
| Caso recursivo | La llamada a sí misma con un problema más pequeño | n! = n · (n - 1)! |
static int factorial(int n) {
if (n <= 1) {
return 1; // caso base
}
return n * factorial(n - 1); // caso recursivo
}
// Dentro del main:
System.out.println(factorial(5)); // 120Así se resuelve factorial(3): cada llamada espera a la siguiente, hasta llegar al caso base, y luego se van multiplicando los resultados de vuelta:
flowchart LR
A["factorial(3)"] -->|"3 · factorial(2)"| B["factorial(2)"]
B -->|"2 · factorial(1)"| C["factorial(1)"]
C -.->|"devuelve 1"| B
B -.->|"devuelve 2"| A
A -.->|"devuelve 6"| R["6"]Otro clásico es la sucesión de Fibonacci, en la que cada número es la suma de los dos anteriores: 0, 1, 1, 2, 3, 5, 8, 13…
static int fibonacci(int n) {
if (n < 2) {
return n; // casos base: fibonacci(0) = 0 y fibonacci(1) = 1
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
// Dentro del main:
for (int i = 0; i < 8; i++) {
System.out.print(fibonacci(i) + " "); // 0 1 1 2 3 5 8 13
}Atención
Sin caso base, o si las llamadas no se acercan a él, la función se llama a sí misma sin fin hasta que Java se queda sin memoria para tantas llamadas: el programa termina con un StackOverflowError.
Todo lo que se hace con recursividad se puede hacer también con un bucle, y casi siempre el bucle gasta menos. La recursividad se usa cuando deja el código más claro.
Errores frecuentes#
| Mensaje o síntoma | Qué significa | Cómo se arregla |
|---|---|---|
missing return statement | La función dice que devuelve algo (int, boolean…), pero hay algún camino por el que termina sin return | Asegúrate de que todos los caminos acaban en return, también el else |
non-static method saludar() cannot be referenced from a static context | Llamas desde main a una función sin static | Añade static a la función: static void saludar() |
method doble in class Programa cannot be applied to given types | La llamada no tiene los datos que pide la función: faltan o sobran (si van en otro orden, el error suele ser incompatible types) | Compara la llamada con los parámetros de la función |
incompatible types: String cannot be converted to int | Le pasas a la función un dato de otro tipo: doble("3") | Pasa el tipo que pide el parámetro: doble(3) |
illegal start of expression | Has escrito una función dentro del main | Sácala fuera del main, dentro de la clase |
method sumar(int,int) is already defined in class … | Dos funciones con el mismo nombre y los mismos parámetros. Cambiar solo el tipo de lo que devuelven no cuenta | Cambia los parámetros de una de ellas, o ponle otro nombre |
Exception in thread "main" java.lang.StackOverflowError | Una función recursiva no llega nunca a su caso base | Comprueba que haya un caso base y que cada llamada se acerque a él (n - 1) |
| Cambias un parámetro dentro de la función y fuera no cambia | La función trabaja con una copia del dato | Devuelve el valor nuevo con return y guárdalo: puntos = subir(puntos); |
| La función «no hace nada» | Has llamado a una función que devuelve un valor, pero no lo guardas ni lo muestras: doble(5); | Guarda el resultado en una variable o úsalo: int d = doble(5); |