Vericode
Entrar

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ódigoSi saludas en cinco sitios del programa, escribes el saludo una vez y lo llamas cinco veces
Dividir un problema grande en partes pequeñasUn juego se puede repartir en pedirJugada(), comprobarGanador(), mostrarTablero()…
Leer mejor el códigoif (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();
    }
}

El programa imprime el saludo dos veces. Las partes de static void saludar() son:

ParteQué significa
staticPor ahora, ponlo siempre (en Java 21). Lo entenderás en el tema de objetos. En Java 25, con void main(), no hace falta
voidLa función no devuelve ningún resultado: solo hace algo
saludarEl 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.

Java
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:

Java
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:

Java
static int doble(int n) {
    return n * 2;
}

// Dentro del main:
int resultado = doble(5);              // resultado vale 10
System.out.println(doble(7));          // 14

return termina la función en ese momento: lo que haya después ya no se ejecuta.

Tipo de la funciónQué devuelveEjemploCómo se usa
voidNadastatic void saludar()saludar();
intUn enterostatic int doble(int n)int d = doble(5);
doubleUn decimalstatic double media(int a, int b)double m = media(4, 7);
booleantrue o falsestatic boolean esPar(int n)if (esPar(8)) { … }
StringUn textostatic String saludo(String nombre)String s = saludo("Ana");

Las que devuelven boolean quedan muy claras dentro de un if:

Java
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:

NombreQué esEjemplo
FunciónCalcula algo y lo devuelve con returnstatic int doble(int n)
ProcedimientoHace algo, pero no devuelve nada (void)static void saludar()
MétodoAsí se llaman las dos en Java, porque siempre están dentro de una clasedoble, 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.

Java
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:

Java
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: 5

Con 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:

Java
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 pasaQué recibe la función¿Se ven fuera sus cambios?
Un int, double, char, boolean…Una copia del valorNo
Un arrayUna copia de la referencia: el mismo arraySí, los de sus posiciones
Un StringUna copia de la referencia, pero un texto no se puede cambiarNo

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:

Java
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 double

Lo 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 @:

Java
/**
 * 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;
}
EtiquetaQué dice
@param nombreQué es ese parámetro. Una por parámetro, en el mismo orden
@returnQué devuelve. Un método void no la lleva
@throws ExcepciónCuá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:

ParteQué esEn el factorial
Caso baseCuándo se para: la respuesta se sabe sin volver a llamar0! y 1! valen 1
Caso recursivoLa llamada a sí misma con un problema más pequeñon! = n · (n - 1)!
Java
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));       // 120

Así 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…

Java
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íntomaQué significaCómo se arregla
missing return statementLa función dice que devuelve algo (int, boolean…), pero hay algún camino por el que termina sin returnAsegúrate de que todos los caminos acaban en return, también el else
non-static method saludar() cannot be referenced from a static contextLlamas desde main a una función sin staticAñade static a la función: static void saludar()
method doble in class Programa cannot be applied to given typesLa 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 intLe 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 expressionHas escrito una función dentro del mainSá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 cuentaCambia los parámetros de una de ellas, o ponle otro nombre
Exception in thread "main" java.lang.StackOverflowErrorUna función recursiva no llega nunca a su caso baseComprueba 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 cambiaLa función trabaja con una copia del datoDevuelve 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);