Un método en Java es un bloque de código reutilizable que realiza una tarea específica. Su definición sigue esta estructura:

public static tipoRetorno nombreMetodo(parametrosFormales) {
    // Cuerpo del método
}

Uso de Parámetros para Flexibilidad

Los parámetros permiten que los métodos reciban datos externos, facilitando la interacción con el código que los invoca. Esto mejora la adaptabilidad y mantenibilidad del software.

Ejemplo de invocación:

nombreMetodo(argumentosReales);

Al definir parámetros formales, se actúan como variables locales declaradas, mientras que los argumentos reales equivalen a la asignación de valores a esas variables.

public static boolean autenticarUsuario(String nombreUsuario, String contrasena) {
    // Lógica de autenticación
}
public static boolean autenticarConCodigo(String user, String pwd, String verificacion) {
    // Incluye código de verificación adicional
}

Valores de Retorno y Tipos

El tipo de retorno especifica el género de dato que el método devuelve, pudiendo ser primitivo, referencia o void para métodos sin retorno. El uso de return es crucial para finalizar la ejecución y proporcionar un resultado.

En métodos con estructuras condicionales, todas las ramas deben retornar un valor adecuado:

if (numero % 2 == 0) {
    return "número par";
} else {
    return "número impar";
}

return en métodos con tipo de retorno finaliza la ejecución y devuelve un valor. En métodos void, return; solo detiene el método sin devolver nada.

Sobrecarga de Métodos

La sobrecarga permite definir múltiples métodos con el mismo nombre dentro de una clase, siempre que difieran en la lista de parámetros (por número, tipo o orden). El tipo de retorno no es un factor determinante.

Resumen de Ventajas

Los métodos promueven la modularidad, reducen la redundancai de código, mejoran la legibilidad y facilitan el mantenimiento y la colaboración en equipos de desarrollo.

Recursión para Probelmas Iterativos

La recursión es una técnica donde un método se invoca a sí mismo para descomponer un problema en subproblemas más pequeños. Es esencial definir una condición de salida válida para evitar recursiones infinitas.

Ejemplos Prácticos

Generación de Separadores

public class EjemploSeparador {
    public static void main(String[] args) {
        System.out.println("Texto inicial");
        dibujarLinea();
        System.out.println("Texto final");
        dibujarLinea();
    }

    public static void dibujarLinea() {
        int contador = 0;
        while (contador < 5) {
            System.out.print("-");
            contador++;
        }
        System.out.println();
    }
}

Parámetros Personalizados

public class EjemploParametros {
    public static void main(String[] args) {
        imprimirPatron(4, '*');
        imprimirPatron(6, '@');
    }

    public static void imprimirPatron(int repeticiones, char simbolo) {
        for (int i = 0; i < repeticiones; i++) {
            System.out.print(simbolo);
        }
        System.out.println();
    }
}

Retorno de Valores Simples

public class EjemploRetorno {
    public static void main(String[] args) {
        int res = multiplicar(3, 4);
        System.out.println("Producto: " + res);
    }

    public static int multiplicar(int a, int b) {
        int producto = a * b;
        return producto;
    }
}

Métodos con Retornos Múltiples

public class EjemploRetornoMultiple {
    public static void main(String[] args) {
        double media = calcularMedia(2.5, 7.5);
        System.out.println("Media: " + media);

        String tipo = esPar(10);
        System.out.println("Tipo de número: " + tipo);

        mostrarSecuencia();
    }

    public static double calcularMedia(double valor1, double valor2) {
        double suma = valor1 + valor2;
        double media = suma / 2;
        System.out.println("Cálculo de media completado");
        return media;
    }

    public static String esPar(int num) {
        if (num % 2 == 0) {
            return "par";
        } else {
            return "impar";
        }
    }

    public static void mostrarSecuencia() {
        int j = 1;
        while (j <= 10) {
            System.out.println("Iteración: " + j);
            if (j == 5) {
                return;
            }
            j++;
        }
    }
}

Cálculo Iterativo de Factorial

public class EjemploFactorialIterativo {
    public static void main(String[] args) {
        int n = 6;
        System.out.println("Factorial de " + n + ": " + obtenerFactorial(n));
    }

    public static int obtenerFactorial(int numero) {
        int factorial = 1;
        int multiplicador = 2;
        while (multiplicador <= numero) {
            factorial *= multiplicador;
            multiplicador++;
        }
        return factorial;
    }
}

Factorial Mediante Recursión

public class EjemploFactorialRecursivo {
    public static void main(String[] args) {
        System.out.println("Factorial recursivo de 6: " + factorialRecursivo(6));
    }

    public static int factorialRecursivo(int n) {
        if (n <= 1) {
            return 1;
        }
        return n * factorialRecursivo(n - 1);
    }
}