Métodos en Java: cómo definir y llamar métodos

Por qué existen los métodos

Un método es un bloque de código con nombre que puedes ejecutar cuando invocas su nombre. En vez de escribir las mismas líneas una y otra vez, las escribes una sola vez dentro de un método y lo llamas tantas veces como necesites. Eso hace que los programas sean más cortos, más fáciles de leer y muchísimo más fáciles de corregir: cambias la lógica en un solo lugar y todos los que lo llaman reciben la actualización.

Ya has estado llamando métodos: System.out.println(...) es una llamada a un método, y list.size() también. Ahora vas a escribir los tuyos.

Declarar y llamar un método

La declaración de un método tiene cuatro partes: un tipo de retorno, un nombre, un par de paréntesis (para los parámetros) y un cuerpo entre llaves. Aquí tienes el ejemplo útil más pequeño: un método que hace algún trabajo y no devuelve nada:

public class Main {
    static void printGreeting() {
        System.out.println("Hello from a method!");
    }

    public static void main(String[] args) {
        printGreeting();   // llámalo
        printGreeting();   // llámalo de nuevo
    }
}

Lee las partes de static void printGreeting():

• static: permite que main lo llame directamente sin crear un objeto (más sobre esto abajo).
• void: este método no devuelve ningún valor.
• printGreeting: el nombre que usas para llamarlo.
• (): los paréntesis vacíos indican que no recibe ninguna entrada.

Llamas a un método escribiendo su nombre seguido de paréntesis. Las dos llamadas en main ejecutan el cuerpo dos veces, así que esto imprime el saludo dos veces.

Devolver un valor

La mayoría de los métodos calculan algo y lo devuelven con return. El tipo de retorno antes del nombre indica qué tipo de dato sale; aquí, int:

public class Main {
    static int square(int n) {
        return n * n;
    }

    public static void main(String[] args) {
        int result = square(5);
        System.out.println(result);          // 25
        System.out.println(square(3) + 1);   // 10
    }
}

square(5) se evalúa como 25, que puedes guardar en una variable, imprimir o usar dentro de una expresión más grande: una llamada a un método representa el valor que devuelve. En el momento en que se ejecuta return, el método termina y el control vuelve a quien lo llamó. Cualquier código que esté después de un return en el mismo camino nunca se ejecuta.

El tipo de retorno y el valor devuelto deben coincidir. Declarar int e intentar return "text"; es un error de compilación: el compilador hace cumplir el contrato.

void frente a un tipo de retorno

La distinción es sencilla: usa un tipo de retorno real cuando quien llama necesita recibir un valor, y void cuando el método solo hace algo (imprime, guarda, actualiza el estado).

void logMessage(String msg)   // hace su trabajo, no devuelve nada
int  add(int a, int b)        // calcula un valor que usa quien llama

Un error común de principiante es intentar usar el "resultado" de un método void:

int x = printGreeting();   // error de compilación: printGreeting() devuelve void

No hay ningún valor que asignar, así que esto no compila. Si te encuentras queriendo el resultado de un método void, es señal de que debería devolver algo.

Métodos que se ramifican y devuelven temprano

Puedes hacer return desde más de un punto. Devolver temprano, en cuanto conoces la respuesta, suele leerse con más claridad que anidarlo todo dentro de else:

public class Main {
    static String grade(int score) {
        if (score >= 90) return "A";
        if (score >= 80) return "B";
        if (score >= 70) return "C";
        return "F";
    }

    public static void main(String[] args) {
        System.out.println(grade(95));   // A
        System.out.println(grade(72));   // C
        System.out.println(grade(50));   // F
    }
}

Como cada return sale de inmediato, gana la primera condición que se cumple. Solo asegúrate de que todo camino a través de un método que devuelve un valor termine en un return: si alguna rama puede salir sin devolver nada, el compilador se queja con "missing return statement". El return "F"; final cubre aquí el caso de salida.

Qué significa static aquí

Quizás hayas notado que todos los métodos de arriba son static. Un método static pertenece a la clase en sí, no a ningún objeto, así que main (que también es static) puede llamarlo directamente por su nombre. Sin static, el método pertenece a una instancia y necesitarías un objeto sobre el cual llamarlo.

Por ahora, mientras escribes programas pequeños cuya lógica vive junto a main, marca tus métodos auxiliares como static para que puedan llamarse de la misma manera. Cuando empieces a construir tus propias clases y objetos, también escribirás métodos no estáticos (de instancia): eso llega con el capítulo de clases.

public class Main {
    static int doubleIt(int n) {
        return n * 2;
    }

    public static void main(String[] args) {
        // main es static, así que puede llamar a doubleIt directamente
        System.out.println(doubleIt(21));   // 42
    }
}

Las variables locales se quedan dentro del método

Las variables declaradas dentro de un método existen solo allí. Se crean cuando el método se ejecuta y desaparecen cuando termina: quien lo llama nunca las ve:

public class Main {
    static int sumTo(int limit) {
        int total = 0;                       // local a sumTo
        for (int i = 1; i <= limit; i++) {
            total += i;
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sumTo(100));      // 5050
        // System.out.println(total);        // error: total no es visible aquí
    }
}

total e i viven por completo dentro de sumTo. Lo único que escapa del método es el valor que return. Este aislamiento es una ventaja: cada método es una unidad autónoma sobre la que puedes razonar sin preocuparte de que sus variables temporales se filtren o choquen con nombres de otro lugar.

Siguiente: parámetros de métodos

Todos los métodos de aquí o no recibían ninguna entrada o recibían un único valor. La verdadera potencia llega al pasar datos hacia dentro, y Java tiene reglas específicas sobre cómo se pasan los argumentos, qué ocurre con los objetos frente a los primitivos y cómo darle a un parámetro algo parecido a un valor por defecto. De eso trata la siguiente página.