Declaración y llamada de métodos, parámetros

1. Sintaxis de la declaración de un método

La declaración de un método en Java se parece a una receta de un libro de cocina: indicas qué devuelve el método (tipo), cómo se llama, qué ingredientes (parámetros) necesita, y escribes la propia receta (cuerpo del método).

Forma general:

tip_vozvrashchaemogo_znacheniya imyaMetoda(parametry)
{
    // aquí escribimos las instrucciones
}

• tipo de valor de retorno — lo que devuelve el método (por ejemplo, int, void — si no devuelve nada, String, etc.).
• nombre del método — nombre que eliges tú (según las reglas de Java).
• parámetros — lista de variables que el método utilizará (puede estar vacía).
• cuerpo del método — tus instrucciones entre llaves { }.

Ejemplos de métodos sin parámetros

void printHello() 
{
    System.out.println("¡Hola, mundo!");
}

Explicación: void — el método no devuelve nada; printHello — nombre; () — no hay parámetros.

Ejemplo de método con parámetros

void printName(String name) 
{
    System.out.println("¡Hola, " + name + "!");
}

Explicación: void — no devuelve valor; printName — nombre del método; String name — un parámetro de tipo String.

Ejemplo de método con varios parámetros

void printSum(int a, int b) 
{
    System.out.println("Suma: " + (a + b));
}

Explicación: los parámetros se indican separados por comas. Dentro del método se usan como variables normales; el operador + realiza la suma.

¡Importante!

• Los métodos se declaran dentro de una clase, pero NO dentro de otros métodos.
• En Java no se pueden declarar métodos dentro de otros métodos — nada de «matrioshkas».

2. Llamada de un método

Declarar un método es como colgar un cartel de «Haré café». Y para que el café aparezca de verdad, hay que llamar al método — escribir su nombre y pasar los valores de los parámetros.

Cómo llamar a un método

Si el método está en la misma clase y está declarado como static (como main), puedes llamarlo simplemente por su nombre:

printHello();
printName("Alisa");
printSum(3, 5);

Si el método no es static, hay que llamarlo a través de un objeto (de esto hablaremos más adelante, cuando estudiemos clases y objetos).

Ejemplo: llamada de un método desde main

public class MethodsDemo
{
    public static void main(String[] args) 
    {
        printHello();
        printName("Bob");
        printSum(10, 20);
    }

    static void printHello() 
    {
        System.out.println("¡Hola, mundo!");
    }

    static void printName(String name) 
    {
        System.out.println("¡Hola, " + name + "!");
    }

    static void printSum(int a, int b) 
    {
        System.out.println("Suma: " + (a + b));
    }
}

Fíjate: los métodos están declarados con el modificador static, para poder llamarlos desde main (que también es static).

3. Parámetros y argumentos: ¿qué son?

Parámetros — son las variables que se declaran entre paréntesis al declarar el método.
Argumentos — son los valores reales que pasas al llamar al método.

Analogía: los parámetros son como la lista de la compra; los argumentos son lo que realmente metes en la cesta.

Ejemplo

      static void greet(String name)  // name — parámetro
{
    System.out.println("¡Hola, " + name + "!");
}

public static void main(String[] args) 
{
    greet("Katya"); // "Katya" — argumento
    greet("Vasya"); // "Vasya" — argumento
}

Cuando llamas a greet("Katya"), dentro del método la variable name pasará a ser igual a "Katya".

Varios parámetros

      static void printInfo(String name, int age)
{
    System.out.println("Nombre: " + name + ", edad: " + age);
}

public static void main(String[] args) 
{
    printInfo("Masha", 25);
    printInfo("Petya", 31);
}

¡Atención! Los tipos y el orden de los parámetros deben coincidir con cómo declaraste el método.

4. Práctica: escribimos nuestros propios métodos

Método que imprime un saludo con el nombre del usuario

static void sayHelloTo(String name)
{
    System.out.println("¡Hola, " + name + "!");
}

public static void main(String[] args)
{
    sayHelloTo("Andrey");
    sayHelloTo("Elvira");
}

Método que calcula la suma de dos números

static void printSum(int a, int b)
{
    int sum = a + b;
    System.out.println("Suma: " + sum);
}

public static void main(String[] args) 
{
    printSum(7, 8);
    printSum(15, -5);
}

Método que imprime los elementos de un array

      static void printArray(int[] array)
{
    System.out.print("Array: ");
    for (int i = 0; i < array.length; i++) 
    {
        System.out.print(array[i] + " ");
    }
    System.out.println();
}

public static void main(String[] args) 
{
    int[] nums = {1, 2, 3, 4, 5};
    printArray(nums);
}

Método que imprime n veces la misma cadena

      static void repeatPrint(String text, int n)
{
    for (int i = 0; i < n; i++) 
    {
        System.out.println(text);
    }
}

public static void main(String[] args) 
{
    repeatPrint("¡Java es genial!", 3);
}

5. Cómo ayudan los métodos a construir una aplicación

Si decides escribir un juego de consola sencillo o una calculadora, el código será más claro si cada tarea se organiza como un método.

Ejemplo: mini-calculadora

public class Calculator
{
    public static void main(String[] args) 
    {
        printGreeting();
        printSum(3, 7);
        printDifference(10, 4);
    }

    static void printGreeting() 
    {
        System.out.println("¡Bienvenido a la calculadora!");
    }

    static void printSum(int a, int b) 
    {
        System.out.println("Suma: " + (a + b));
    }

    static void printDifference(int a, int b) 
    {
        System.out.println("Diferencia: " + (a - b));
    }
}

En el futuro podrás añadir nuevos métodos (multiplicación, división, trabajo con arrays de números, etc.), y la aplicación irá creciendo sin convertirse en un bloque interminable de código.

6. Detalles útiles

Nombres de los métodos

• El nombre de un método suele empezar en minúscula y se escribe en estilo camelCase: printSum, sayHelloTo, calculateArea.
• El nombre debe reflejar la acción. Evita doStuff y method1.

Orden de los parámetros

• Respeta el orden y los tipos de los parámetros al llamar.
• Si el método acepta printInfo(String name, int age), no se puede invocar printInfo(25, "Masha").

¿Se pueden declarar dos métodos con el mismo nombre?

Sí, si tienen distinto listado de parámetros (tipos o cantidad). Esto es sobrecarga de métodos:

static void printSum(int a, int b) { /* ... */ }
static void printSum(int a, int b, int c) { /* ... */ }

A este tema le dedicaremos una lección aparte — por ahora basta con saber que Java no se limita a un único método por nombre.

7. Errores típicos al trabajar con métodos y parámetros

Error n.º 1: No coinciden la cantidad o los tipos de parámetros en la llamada.
Si el método está declarado como printSum(int a, int b), y lo llamas como printSum(5), el compilador dirá que no existe tal método. Del mismo modo, printSum("cinco", 7) — error de tipos.

Error n.º 2: Confundir parámetros y argumentos.
En la declaración del método se escriben los parámetros (por ejemplo, int a, int b), y en la llamada — los argumentos (printSum(5, 7)). No hace falta crear en main variables con los mismos nombres — lo importante es que coincidan los tipos y el orden.

Error n.º 3: Intentar declarar un método dentro de otro método.
En Java los métodos solo se declaran a nivel de clase. Dentro de otro método no se pueden declarar.

Error n.º 4: No usar static al llamar desde main.
Si llamas a un método desde main, añade static a su declaración o crea un objeto y llama al método sobre él. Más detalles — más adelante, al estudiar POO.