Métodos

Los elementos de una clase también disponen de comportamientos. Estos comportamientos se llaman métodos y son similares a las funciones de la programación estructurada. Por ejemplo, la clase Persona puede tener los siguientes métodos: saludar, cumplirAnios, crecer, etc.

Definamos los distintos elementos de un método:

• Prototipo del método: es la declaración del método. Se especifica el nombre, el tipo de dato que devuelve y los parámetros que utiliza.
• Cuerpo del método: es el bloque de código que ejecuta el método cada vez que recibe un mensaje.

Prototipo de métodos

La sintaxis del prototipo de método es la siguiente:

tipoRetorno nombreMetodo(tipoParametro1 parametro1, tipoParametro2 parametro2,...) {
    //cuerpo del método
}

Tipo de dato de retorno

tipoRetorno es el tipo de dato del valor devuelto por el método. Puede ser cualquier tipo de dato primitivo o una clase. Si no se devuelve ningún tipo de dato, se utiliza el literal void.

Parámetros de entrada

En cuanto a los parámetros de entrada, pueden definirse tantos como sean necesarios, pero también es posible que no se necesite ninguno, por lo que los paréntesis estarían vacíos. Para cada parámetro debemos indicar su tipo de dato y el nombre del parámetro.

El método cumplirAnios, por ejemplo, no necesita ningún parámetro de entrada ni devuelve ningún valor. Por lo tanto, su prototipo sería el siguiente:

void cumplirAnios() {
    // cuerpo
}

El método crecer necesita como parámetro de entrada el incremento, que es un double, y en este caso tampoco devuelve nada. Por lo tanto tenemos el siguiente prototipo:

void crecer(double incremento) {
    // cuerpo
}

Un tercer ejemplo sería el método saludar que nos devolvería un String, que sería el saludo de la persona. No necesitaría ningún parámetro de entrada.

String saludar() {
    // cuerpo
}

Cuerpo de métodos

Dentro del cuerpo de los métodos podemos utilizar tanto los parámetros de entrada del método como los atributos de la clase. Por ejemplo, en el método cumplirAnios utilizamos el atributo edad:

void cumplirAnios() {
    edad++;
}

En el caso del método crecer utilizamos tanto los parámetros de entrada como los atributos de la clase:

void crecer(double incremento) {
    estatura += incremento;
}

En el método saludar necesitamos devolver un valor. Esto se realiza con la palabra reservada return. El funcionamiento de este operador es similar al visto en Python:

String saludar() {
    return "Hola";
}

Ejemplo completo de la clase Persona

class Persona {
    String nombre;
    int edad;
    double estatura;
    
    void cumplirAnios(){
        edad++;
    }
    
    void crecer(double incremento){
        estatura+=incremento;
    }
    
    String saludar(){
        return "Hola";
    }
    
}

Invocación de métodos

Para poder llamar a un método necesitamos un objeto de la clase correspondiente. Para invocarlo utilizamos un punto (.) al igual que se hace con los atributos:

Persona p = new Persona();
p.edad = 18;
p.cumplirAnios();
System.out.println(p.edad); //Imprime el valor 19
System.out.println(p.saludar()); //Imprime "Hola"
p.estatura = 1.70;
p.crecer(0.21);
System.out.println(p.estatura); //Imprime 1,91

Métodos con número variable de parámetros: varargs

En Java, los métodos con varargs permiten pasar un número variable de argumentos del mismo tipo a un método. Esto se consigue utilizando el operador ... en el tipo del parámetro. El término varargs viene de variable-length arguments (argumentos de longitud variable).

El operador ... indica al compilador que el método puede recibir cero o más argumentos de ese tipo. Internamente, Java trata los argumentos como un array del tipo especificado:

void metodoConVarargs(Tipo... argumentos) {
    // Aquí "argumentos" se trata como un array de Tipo
    for (Tipo argumento : argumentos) {
        System.out.println(argumento);
    }
}

Veamos un ejemplo completo:

public class EjemploVarargs {
    // Método que suma cualquier número de valores
    int sumar(int... numeros) {
        int suma = 0;
        for (int numero : numeros) {
            suma += numero;
        }
        return suma;
    }

    public static void main(String[] args) {
        EjemploVarargs ejemplo = new EjemploVarargs();

        // Llamar al método con diferente número de argumentos
        System.out.println(ejemplo.sumar());               // 0 (sin argumentos)
        System.out.println(ejemplo.sumar(5));              // 5 (un argumento)
        System.out.println(ejemplo.sumar(1, 2, 3, 4, 5));  // 15 (varios argumentos)
    }
}

Aquí algunas reglas importantes para varargs:

• Un solo parámetro varargs por método: Solo puede haber un único parámetro con ... en un método.

  void metodoIncorrecto(int... a, String... b) {}   // No es válido.
  void metodoCorrecto(int... a) {}                  // Es válido.

• Debe ser el último parámetro: Si un método tiene más parámetros, el de tipo varargs debe ser el último.

  void metodoIncorrecto(int... valores, String nombre) {}   // No es válido.
  void metodoCorrecto(String nombre, int... valores) {}     // Es válido.

• Puede recibir cero o más valores: Si no se pasa ningún argumento, el array será de longitud 0.

Documentación de métodos

En Java, la documentación se realiza normalmente usando comentarios Javadoc, que son especiales porque se pueden generar automáticamente como documentación en formato HTML.

Los comentarios Javadoc se colocan justo encima de la definición de un método o clase y tienen la siguiente estructura:

/**
 * Descripción breve de lo que hace el método.
 *
 * @param nombreParametro1 Descripción del primer parámetro.
 * @param nombreParametro2 Descripción del segundo parámetro.
 * ...
 * @return Descripción del valor de retorno, si aplica.
 * @throws NombreExcepcion Condiciones en las que se lanza una excepción, si aplica.
 */

• Descripción breve → Explica de forma rápida el propósito del método.
• @param → Indica y describe cada parámetro que el método recibe.
• @return → Describe el valor de retorno del método (si el método no devuelve nada, esta etiqueta no es necesaria).
• @throws → Describe las excepciones que el método puede lanzar y en qué circunstancias.

AutoDoc en Visual Studio Code

En Visual Studio Code, si en la línea antes de la definición de un método escribimos /** y pulsamos Enter, se generará la estructura de la documentación y solo deberemos escribir la información necesaria.

Ejemplo:

/**
 * Este método suma dos números enteros.
 *
 * @param a El primer número.
 * @param b El segundo número.
 * @return La suma de a y b.
 */
public int sumar(int a, int b) {
    return a + b;
}