Programación Modular en Java: Construyendo Software como si fueran LEGOs

¡Hola, equipo! Si en el tema anterior sentamos las bases de la programación estructurada para dejar atrás el caos, ahora vamos a dar el siguiente paso para convertirnos en auténticos arquitectos de software. ¿Habéis montado alguna vez un set de LEGO complejo, como el Halcón Milenario o un coche de Technic? No empiezas uniendo piezas al azar, ¿verdad? Sigues un manual que agrupa las instrucciones en pasos: "primero, monta el motor", "luego, construye el chasis", "finalmente, ensambla la cabina". Cada uno de esos subconjuntos es una pieza completa y funcional por sí misma.

La programación modular es exactamente eso. Es la filosofía de "divide y vencerás" aplicada al código. En lugar de escribir un único bloque de miles de líneas en el main (el equivalente a tirar todas las piezas de LEGO en el suelo y rezar), descomponemos un problema gigante en subproblemas pequeños y manejables. Cada uno de estos subproblemas se resuelve en su propio "módulo", que en Java llamamos métodos.

En el mundo laboral, nadie os pedirá construir una aplicación entera en un solo archivo. Trabajaréis en equipos donde un compañero se encarga del módulo de autenticación, otro del sistema de pagos y vosotros del perfil de usuario. La programación modular no es solo una buena práctica; es la única forma viable de construir software robusto, mantenible y escalable. ¡Vamos a aprender a construir nuestros propios "kits de LEGO" de código!

A finales de los 60, el software era un caos. Los programadores usaban una instrucción llamada GOTO que permitía saltar de cualquier punto del programa a cualquier otro. El resultado era el famoso "código espagueti": un lío de saltos imposible de seguir, depurar o mantener.

La programación estructurada nació como la solución a este caos. El Teorema del Programa Estructurado (de Böhm y Jacopini) demostró matemáticamente que cualquier algoritmo, por complejo que sea, puede construirse usando únicamente tres estructuras de control básicas:

1. Secuencia: Ejecutar instrucciones una detrás de otra.
2. Selección (o Condicional): Elegir entre dos o más caminos de ejecución (if, switch).
3. Iteración (o Bucle): Repetir un bloque de código (while, for).

Estos tres pilares son la base de casi todos los lenguajes de programación modernos, incluido JAVA. Dominarlos es dominar la lógica fundamental de la programación.

1. Conceptos Fundamentales

Antes de empezar a construir, necesitamos conocer nuestras herramientas y materiales. Estos son los términos clave que usarás a diario.

2. Programación Modular

A medida que los programas crecen, meter todo el código dentro del método main se vuelve una pesadilla. La programación modular es la solución: consiste en descomponer un problema grande en subproblemas más pequeños y manejables, y crear "módulos" de código para resolver cada uno. En JAVA, estos módulos son los métodos (que engloban tanto funciones como procedimientos).

2.1. Desarrollo y Ejemplos Prácticos

Imagina que te encargan desarrollar una app como Discord. La tarea es gigantesca. Pero si la divides, la cosa cambia:
* Un módulo para gestionar el login de usuarios.
* Un módulo para enviar y recibir mensajes en un canal.
* Un módulo para gestionar las llamadas de voz.
* Un módulo para administrar los roles y permisos de un servidor.

De repente, el problema se ha transformado en cuatro problemas más pequeños y mucho más fáciles de abordar. Esta es la esencia de la descomposición modular.

graph TD
    subgraph "Problema Gigante"
        A[Desarrollar Discord]
    end

    subgraph "Subproblemas (Módulos)"
        B[Gestión de Usuarios]
        C[Chat en Tiempo Real]
        D[Llamadas de Voz/Vídeo]
        E[Administración de Servidores]
    end

    A -->|"Divide y Vencerás"| B
    A -->|"Divide y Vencerás"| C
    A -->|"Divide y Vencerás"| D
    A -->|"Divide y Vencerás"| E

    B --> F{Aplicación Final}
    C --> F
    D --> F
    E --> F

Las ventajas son inmediatas y transformadoras:
* Claridad y Legibilidad: Un método calculateUserTaxes() es infinitamente más fácil de entender que buscar esas 20 líneas de código perdidas en un método main de 2000 líneas.
* Reutilización: ¿Necesitas validar un email en 5 sitios distintos de tu app? Creas un método isValidEmail(String email) una vez y lo llamas 5 veces. ¡Adiós al código duplicado!
* Facilidad de Depuración: Si hay un error en el cálculo de impuestos, sabes que el bug está dentro de calculateUserTaxes(). No tienes que cazarlo por toda la aplicación. Aislar y corregir errores se vuelve trivial.
* Trabajo en Equipo: Permite que varios programadores trabajen en paralelo en distintos módulos sin pisarse los unos a los otros.

2.2. Anatomía de un Método: Funciones vs. Procedimientos

En Java, todos son métodos, pero es crucial distinguir entre los que devuelven un valor (funciones) y los que no (procedimientos).

Un método se declara definiendo su cabecera y su cuerpo, dentro de una clase JAVA.

La cabecera de un método se define, en este orden:
● Acceso(modificadores de visibilidad y directiva static).
● Tipo de retorno, o tipo de sus resultados (valores de retorno).
● Nombre (identificador).
● Lista de parámetros, o los tipos y nombres de sus datos (parámetros).

El cuerpo es la secuencia de instrucciones que se ejecutan al invocarlo, puede incluir:
● Declaraciones de variables.
● Cualquier tipo de instrucción o bloque de instrucciones: asignación, condicional, bucle, e incluso, llamadas o invocaciones a otros métodos.

En JAVA se debe indicar el tipo de dato de retorno antes del identificador.

static int suma(int a, int b) { … } /*declaramos un método con
identificador suma y que retorna un valor entero(int) */

Como resultado de su invocación, un método devuelve unos resultados, los denominados valores de retorno.
● El tipo de retorno de un método puede ser cualquier tipo de dato en JAVA (int, double, char, String, boolean, etc.). También pueden devolver objetos.
● Para devolver un valor, dentro del método se debe utilizar la instrucción return. En concreto, el valor de retorno debe aparecer después de la palabra reservada return.

Además, se deben tener en cuenta las siguientes consideraciones:
○ La ejecución de un método finaliza tras la ejecución de cualquiera de los return que aparecen en su cuerpo.
○ Si un método no devuelve explícitamente ningún valor, entonces el tipo de su resultado es void. En este caso, implícitamente, se ejecuta “return” como última instrucción del método.

2.3. Funciones: Los Métodos que Devuelven un Valor

Una función realiza un cálculo o una operación y te entrega el resultado. Utiliza la palabra clave return para devolver el valor. El tipo de dato que devuelve debe coincidir con el declarado en la firma del método.

Ejemplo 1: Calculando el bono de un empleado

public class HumanResources {

    /**
     * Calcula el bono anual de un empleado basado en su rendimiento.
     * Es una función porque calcula y devuelve un valor numérico.
     *
     * @param baseSalary El salario base del empleado.
     * @param performanceRating Una calificación de rendimiento de 1 (malo) a 5 (excelente).
     * @return El monto del bono calculado en euros.
     */
    public static double calculateBonus(double baseSalary, int performanceRating) {
        double bonusPercentage;

        // Usamos un switch expression (Java 14+) para más claridad
        bonusPercentage = switch (performanceRating) {
            case 5 -> 0.20;  // 20% para rendimiento excelente
            case 4 -> 0.15;  // 15% para bueno
            case 3 -> 0.10;  // 10% para promedio
            default -> 0.0; // 0% para por debajo del promedio
        };

        return baseSalary * bonusPercentage;
    }

    public static void main(String[] args) {
        double salary = 50000.0;
        int rating = 4;

        // Llamamos a la función y almacenamos el resultado
        double employeeBonus = calculateBonus(salary, rating);

        System.out.println("Salario: " + salary + "€, Calificación: " + rating);
        System.out.println("Bono Anual: " + employeeBonus + "€"); // Imprime 7500.0€
    }
}

Ejemplo 2: Creando un nombre de usuario único

import java.util.Random;

public class UserRegistration {

    /**
     * Genera un nombre de usuario sugerido combinando nombre, apellido y un número aleatorio.
     *
     * @param firstName El nombre de la persona.
     * @param lastName El apellido de la persona.
     * @return Un String con el nombre de usuario sugerido (ej: "jdoe789").
     */
    public static String generateUsername(String firstName, String lastName) {
        if (firstName == null || lastName == null || firstName.isEmpty() || lastName.isEmpty()) {
            return "default_user";
        }

        String firstInitial = firstName.substring(0, 1).toLowerCase();
        String lastNameShort = lastName.toLowerCase();
        if (lastNameShort.length() > 5) {
            lastNameShort = lastNameShort.substring(0, 5);
        }

        int randomNumber = new Random().nextInt(900) + 100; // Número aleatorio entre 100 y 999

        return firstInitial + lastNameShort + randomNumber;
    }

    public static void main(String[] args) {
        String user1 = generateUsername("John", "Doe");
        String user2 = generateUsername("Samantha", "Williamson");

        System.out.println("Usuario sugerido para John Doe: " + user1);
        System.out.println("Usuario sugerido para Samantha Williamson: " + user2);
    }
}

2.4. Procedimientos: Los Métodos que Realizan Acciones (void)

Un procedimiento ejecuta una serie de pasos pero no devuelve nada. Su propósito es cambiar el estado de algo o realizar una acción, como imprimir en consola, guardar en un fichero o modificar un objeto. Se identifican por la palabra clave void en su firma.

Ejemplo 1: Un procedimiento para mostrar un mensaje de bienvenida

public class UserInterface {

    /**
     * Muestra un mensaje de bienvenida personalizado en la consola.
     * Es un procedimiento porque su única acción es imprimir, no devuelve nada.
     *
     * @param username El nombre del usuario a saludar.
     */
    public static void displayWelcomeMessage(String username) {
        System.out.println("======================================");
        System.out.println("¡Bienvenido de vuelta, " + username + "!");
        System.out.println("Tu panel de control está listo.");
        System.out.println("======================================");
    }

    public static void main(String[] args) {
        // Llamamos al procedimiento para que realice su acción
        displayWelcomeMessage("AdminUser");
    }
}

Ejemplo 2: Un procedimiento para registrar un evento en un log

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class SystemLogger {

    /**
     * Registra un mensaje de evento con un nivel de severidad y marca de tiempo.
     *
     * @param level El nivel del log (ej: "INFO", "WARNING", "ERROR").
     * @param message El mensaje a registrar.
     */
    public static void logEvent(String level, String message) {
        String timestamp = LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
        System.out.println("[" + timestamp + "] [" + level + "] - " + message);
    }

    public static void main(String[] args) {
        logEvent("INFO", "El sistema se ha iniciado correctamente.");
        logEvent("WARNING", "La memoria está al 85% de su capacidad.");
        logEvent("ERROR", "No se pudo conectar a la base de datos.");
    }
}

2.5. Parámetros: Paso por Valor vs. Paso por Referencia

Este es uno de los conceptos más importantes y que más confusiones genera. Es crucial entender cómo JAVA maneja los parámetros.

graph TD
    A[Paso por Valor] --> B[Copia del valor]
    A --> C[Modificaciones no se reflejan]
    D[Paso por Referencia] --> E[Dirección de memoria]
    D --> F[Modificaciones afectan original]

Los métodos serían inútiles si no pudieran recibir información para trabajar. Los parámetros son su canal de entrada de datos. Entender cómo Java los maneja es, sin exagerar, uno de los pilares para evitar futuros dolores de cabeza.

La Regla de Oro en JAVA:

¿Y esto qué significa en la práctica?

• Primitivos (Paso por Valor Puro): Le das al método una fotocopia de un número. Si el método tacha y escribe encima de la fotocopia, tu número original permanece intacto.
• Objetos (Paso por Copia de Referencia): Le das al método una fotocopia de la dirección de tu casa. El método no puede cambiar la dirección para que apunte a otra casa (no puede hacer que tu variable original apunte a otro objeto). Pero sí puede ir a la dirección que le has dado y pintar la puerta de verde (modificar el estado interno del objeto). Tu casa original ahora tendrá la puerta verde.

Ejemplo Práctico: Primitivos vs. Objetos

public class ParameterPassingDemo {

    // Recibe un tipo primitivo. Cualquier cambio es local.
    public static void attemptToModifyPrimitive(int health) {
        System.out.println("  -> Método recibe health: " + health);
        health = 0; // Modificamos la COPIA local.
        System.out.println("  -> Método modifica health a: " + health);
    }

    // Recibe un objeto (array). Puede modificar el estado del objeto.
    public static void modifyObjectState(String[] inventory) {
        System.out.println("  -> Método recibe inventario[0]: " + inventory[0]);
        // Modificamos el contenido del objeto al que apunta la referencia
        inventory[0] = "Espada Rota";
        System.out.println("  -> Método modifica inventario[0] a: " + inventory[0]);
    }

    public static void main(String[] args) {
        // --- Paso por valor con PRIMITIVOS ---
        int playerHealth = 100;
        System.out.println("Vida del jugador ANTES de llamar al método: " + playerHealth);
        attemptToModifyPrimitive(playerHealth);
        System.out.println("Vida del jugador DESPUÉS de llamar al método: " + playerHealth);

        System.out.println("\n-----------------------------------------\n");

        // --- Paso por "valor de la referencia" con OBJETOS ---
        String[] playerInventory = {"Espada de Acero", "Poción"};
        System.out.println("Inventario ANTES de llamar al método: " + playerInventory[0]);
        modifyObjectState(playerInventory);
        System.out.println("Inventario DESPUÉS de llamar al método: " + playerInventory[0]);
    }
}

sequenceDiagram
    participant main as "main()"
    participant metodo as "metodo()"

    main->>main: int vidaPrimitiva = 100;
    main->>main: int[] statsObjeto = {50, 20};

    Note right of main: 'vidaPrimitiva' vale 100.
    main->>metodo: reducirVida(vidaPrimitiva);
    Note left of metodo: Se crea una COPIA de 'vidaPrimitiva'<br>con valor 100.
    metodo->>metodo: La copia se reduce a 80.
    Note left of metodo: La 'vidaPrimitiva' original en main()<br>SIGUE VALIENDO 100.
    metodo-->>main: finaliza

    Note right of main: 'statsObjeto' apunta a una dirección<br>de memoria con [50, 20].
    main->>metodo: aplicarVeneno(statsObjeto);
    Note left of metodo: Se crea una COPIA de la dirección de memoria.<br>Ambas referencias apuntan al MISMO objeto [50, 20].
    metodo->>metodo: Se modifica el objeto: statsObjeto[0] = 45;
    Note left of metodo: Se está cambiando el objeto original<br>a través de la referencia copiada.
    metodo-->>main: finaliza
    Note right of main: ¡El array original en main()<br>AHORA CONTIENE [45, 20]!

La analogía:
* Paso de primitivos: Te doy una fotocopia de mi número de teléfono. Si tú tachas la fotocopia, mi número original en mi agenda sigue intacto.
* Paso de objetos: Te doy una fotocopia de la dirección de mi casa. No puedes cambiar la dirección para que apunte a otra casa (no puedes reasignar la referencia), pero sí puedes ir a esa dirección y pintar la puerta de verde (modificar el estado del objeto). Mi casa (el objeto original) ahora tendrá la puerta verde.

2.6. Ámbito de las Variables (Scope): "Lo que se declara en un método, se queda en el método"

El ámbito o scope de una variable define dónde es visible y accesible esa variable en tu programa. Es como la jurisdicción de un policía: solo puede actuar dentro de sus límites. En Java, estos límites están definidos principalmente por las llaves {}.

graph TD
    A[Ámbito] --> B[Global]
    A --> C[Local]
    C --> D[Función]
    C --> E[Bloque]

Ejemplo Práctico: Demostración de Ámbitos

public class ScopeDemo {

    // 1. VARIABLE DE CLASE (static). "Global" para esta clase.
    // Accesible desde cualquier método (static) de la clase.
    public static final String GAME_VERSION = "v1.2.0";

    public static void playerSetup() {
        // 2. VARIABLE LOCAL al método playerSetup.
        String playerName = "Aragorn";
        System.out.println("Configurando a " + playerName + " para el juego " + GAME_VERSION);

        if (true) {
            // 3. VARIABLE LOCAL al bloque 'if'.
            String setupMessage = "¡Personaje listo!";
            System.out.println(setupMessage); // OK: Visible dentro de su bloque.
            System.out.println(playerName);   // OK: El bloque hijo puede ver las variables del padre.
        }

        // ¡ERROR DE COMPILACIÓN! 'setupMessage' no existe aquí. Murió al cerrar la llave del 'if'.
        // System.out.println(setupMessage); 
    }

    public static void main(String[] args) {
        System.out.println("Iniciando el motor del juego. Versión: " + GAME_VERSION);
        playerSetup();

        // ¡ERROR DE COMPILACIÓN! 'playerName' no existe en el ámbito de 'main'.
        // System.out.println("El jugador es: " + playerName);
    }
}

3. Sobrecarga de Métodos

En Java, es posible definir múltiples métodos con el mismo nombre, siempre que se cumplan las siguientes condiciones:

• Si el método tiene un solo parámetro, cada método debe usar un tipo de parámetro diferente.
  
• Si hay más de un parámetro, al menos uno de ellos debe ser de un tipo distinto.
  
• Si el método no tiene parámetros, no se permite otro método con el mismo nombre.
  

Ejemplo:

static String bienvenida() {
    return "¡Hola, qué tal estás?";
}

static String bienvenida(String usuario) {
    return "¡Hola, " + usuario + "! ¿Qué tal estás?";
}

static String bienvenida(String usuario, String lugar) {
    return "¡Hola, " + usuario + "! ¿Cómo estás en " + lugar + "?";
}

En JAVA podemos tener métodos con el mismo nombre, pero se debe tener en cuenta que aunque el tipo de retorno sea distinto, si los parámetros son iguales, se producirá un error de compilación. Esto se debe a que JAVA realmente no sabe el método que debe utilizar.

4. Recursividad: El Arte de los Métodos que se Llaman a Sí Mismos

La recursividad es una técnica de programación donde un método se llama a sí mismo para resolver un problema. Es una alternativa a los bucles (iteración) y es increíblemente elegante para ciertos tipos de problemas, como los matemáticos o los que implican estructuras de datos jerárquicas (como árboles de archivos).

Todo método recursivo debe tener dos elementos clave:
1. Caso Base: Una condición que detiene la recursividad. Sin él, el método se llamaría a sí mismo infinitamente, provocando un error StackOverflowError (¡sí, como la web de donde copiamos el código!).
2. Llamada Recursiva: La parte del método que se llama a sí misma, pero con un argumento que lo acerca cada vez más al caso base.

4.1. Ejemplos recursivos

Suma Recursiva de números desde 1 hasta N

Programa recursivo que calcula la suma desde 1 hasta un número entero N leído por teclado.

La solución recursiva se basa en lo siguiente:

Caso Base: Si n == 1 la suma es 1

Si n > 1 la suma es n + (la suma de los anteriores números hasta 1)
Por ejemplo, si n = 5, la suma es 5 más la suma desde 1 hasta 4.

A su vez la suma si n = 4 es 4 + la suma desde 1 hasta 3 y así sucesivamente hasta llegar al caso base como se muestra en la imagen.

El programa que calcula la suma desde 1 hasta N de forma recursiva es el siguiente:

import java.util.Scanner;
public class Suma1N {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num;
        do{
           System.out.print("Introduce un numero entero >0 ");
           num = sc.nextInt();
        }while(num <= 0);
        System.out.println("Suma desde 1 hasta " + num + " = " + suma1N(num));                                    

    }

    //método recursivo para calcular la suma desde 1 hasta N
    public static double suma1N(int n){
           if(n == 1) { //caso base
              return 1;
           } else {
              return n + suma1N(n-1);
           }
    }
}

Ejemplo Clásico: El Factorial de un Número

El factorial de 5 ( 5! ) es 5 * 4 * 3 * 2 * 1. Esto se puede definir recursivamente:
* factorial(n) = n * factorial(n-1)
* Caso Base: factorial(0) = 1

public class RecursionExample {

    /**
     * Calcula el factorial de un número usando recursividad.
     *
     * @param n El número (no negativo) del que calcular el factorial.
     * @return El resultado del factorial.
     */
    public static long factorial(int n) {
        // Caso Base: Si n es 0, el factorial es 1. La recursividad se detiene aquí.
        if (n == 0) {
            System.out.println("Caso Base alcanzado. Retornando 1.");
            return 1;
        } else {
            // Llamada Recursiva: Llama a sí misma con un problema más pequeño (n-1).
            System.out.println("Calculando " + n + " * factorial(" + (n - 1) + ")");
            return n * factorial(n - 1);
        }
    }

    public static void main(String[] args) {
        int number = 4;
        long result = factorial(number);
        System.out.println("\nEl factorial de " + number + " es: " + result);
    }
}

Ejemplo 2: Cuenta atrás

public class Countdown {

    /**
     * Imprime una cuenta atrás desde un número n hasta 0.
     * @param n El número de inicio.
     */
    public static void countdown(int n) {
        // Caso Base:
        if (n < 0) {
            return; // Detiene la recursión
        }

        System.out.println(n);

        // Llamada Recursiva:
        countdown(n - 1);
    }

    public static void main(String[] args) {
        System.out.println("¡Lanzamiento en...!");
        countdown(5);
        System.out.println("¡Despegue!");
    }
}

Aplicación en el Mundo Real

La programación modular no es un concepto académico; es la columna vertebral del desarrollo de software moderno.
* APIs y Librerías: Cuando usas una librería como Google Maps en tu app, no tienes acceso a todo su código. Simplemente llamas a los métodos (módulos) que Google ha expuesto para ti, como map.addMarker() o map.setZoom(). Estás consumiendo una API (Interfaz de Programación de Aplicaciones), que es la máxima expresión de la modularidad.
* Frameworks (Spring, Angular, etc.): Un framework te proporciona una estructura de "esqueleto" para tu aplicación, llena de módulos pre-construidos para la seguridad, el acceso a bases de datos, la gestión de peticiones web, etc. Tu trabajo es "rellenar los huecos" con tus propios módulos que contienen la lógica específica de tu negocio.
* Arquitectura de Microservicios: Es la programación modular llevada al extremo. Empresas como Netflix o Amazon no tienen una sola aplicación monolítica. Tienen cientos de pequeños servicios independientes (un microservicio para el catálogo de películas, otro para las recomendaciones, otro para la facturación...). Cada microservicio es un programa modular en sí mismo, y se comunican entre ellos a través de la red. Esto les permite escalar, actualizar y mantener su plataforma de forma increíblemente eficiente.

Para Saber Más

Para seguir profundizando en el arte de la programación modular en Java, te recomiendo estos recursos de alta calidad:

1. Documentación Oficial de Oracle sobre Métodos: Defining Methods - The Java™ Tutorials. Ir a la fuente oficial siempre es la mejor opción para obtener información precisa y detallada.
2. Baeldung - A Guide to the Method in Java: A Guide to the Method in Java. Baeldung es una referencia imprescindible en el ecosistema Java, con explicaciones claras y ejemplos prácticos excelentes.
3. Vídeo-Tutorial - Java Methods de "Bro Code": Java Methods ☕. Un tutorial en vídeo, directo y entretenido, que cubre los fundamentos de los métodos de una manera muy visual. Ideal para reforzar lo aprendido.

---

EJERCICIOS

=> Ejercicios de Programación modular