Fundamentos de sobrecarga de métodos

Parte de la sección Programación Orientada a Objetos del Journey de Java de Coddy — lección 28 de 87.

Polimorfismo significa "muchas formas". En Java, permite que los objetos se comporten de manera diferente según el contexto. Una forma de polimorfismo es la sobrecarga de métodos, también llamada polimorfismo en tiempo de compilación porque Java determina qué método llamar durante la compilación.

La sobrecarga de métodos le permite definir múltiples métodos con el mismo nombre pero diferentes parámetros. El compilador los distingue basándose en el número, tipo o el orden de los parámetros:

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
}

Cuando llamas a add(5, 3), Java usa el primer método. Al llamar a add(5, 3, 2) se activa el segundo, y add(5.0, 3.0) invoca el tercero. El compilador elige la versión correcta basándose en los argumentos que proporciones.

Ten en cuenta que cambiar solo el tipo de retorno no es una sobrecarga válida. La lista de parámetros debe ser diferente:

// NO es una sobrecarga válida - no compilará
public int getValue() { return 1; }
public double getValue() { return 1.0; }  // ¡Error!

De hecho, ya has visto la sobrecarga anteriormente con la sobrecarga de constructores. La sobrecarga de métodos sigue las mismas reglas y proporciona flexibilidad al permitir que un solo nombre de método maneje diferentes escenarios de entrada.

Desafío

Fácil

Vamos a construir un formateador de mensajes que demuestre la sobrecarga de métodos proporcionando múltiples formas de formatear mensajes. Crearás una clase de utilidad con varios métodos format sobrecargados que manejan diferentes escenarios de entrada.

Organizarás tu código en dos archivos:

MessageFormatter.java: Crea una clase que proporcione un formateo de mensajes flexible a través de métodos sobrecargados. Tu formateador debe tener:
- Un método format(String message) que devuelva el mensaje envuelto en corchetes: [message]
- Un método format(String message, int repeatCount) que devuelva el mensaje repetido el número especificado de veces, separado por espacios
- Un método format(String message, String prefix) que devuelva el mensaje con el prefijo adjunto: prefix: message
- Un método format(String message, String prefix, String suffix) que devuelva: prefix: message (suffix)
El compilador elegirá el método correcto basándose en los argumentos que pases; ¡eso es el polimorfismo en tiempo de compilación en acción!
Main.java: Demuestra los cuatro métodos sobrecargados trabajando juntos. Recibirás cuatro entradas: un mensaje (String), un recuento de repeticiones (int), un prefijo (String) y un sufijo (String). Crea un MessageFormatter y llama a cada versión del método format, imprimiendo cada resultado en su propia línea:
- Primero, formatea solo con el mensaje
- Segundo, formatea con el mensaje y el recuento de repeticiones
- Tercero, formatea con el mensaje y el prefijo
- Cuarto, formatea con el mensaje, el prefijo y el sufijo

Recibirás cuatro entradas: el texto del mensaje, cuántas veces repetirlo, una cadena de prefijo y una cadena de sufijo.

Por ejemplo, si el mensaje es "Hello", el recuento de repeticiones es 3, el prefijo es "INFO" y el sufijo es "done", ¡tu salida debería mostrar cuatro versiones formateadas diferentes del mismo mensaje, cada una utilizando un método sobrecargado diferente!

Hoja de referencia

La sobrecarga de métodos permite definir múltiples métodos con el mismo nombre pero diferentes parámetros. Esto también se conoce como polimorfismo en tiempo de compilación porque Java determina qué método llamar durante la compilación.

El compilador distingue los métodos sobrecargados basándose en el número, tipo o el orden de los parámetros:

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
}

Al llamar a add(5, 3), Java utiliza el primer método. Llamar a add(5, 3, 2) activa el segundo, y add(5.0, 3.0) invoca al tercero.

Importante: Cambiar solo el tipo de retorno no es una sobrecarga válida. La lista de parámetros debe ser diferente:

// NO es una sobrecarga válida
public int getValue() { return 1; }
public double getValue() { return 1.0; }  // Error!

Pruébalo tú mismo

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Leer entradas
        String message = scanner.nextLine();
        int repeatCount = Integer.parseInt(scanner.nextLine());
        String prefix = scanner.nextLine();
        String suffix = scanner.nextLine();
        
        // TODO: Crear un objeto MessageFormatter
        
        // TODO: Llamar a format solo con el mensaje e imprimir el resultado
        
        // TODO: Llamar a format con el mensaje y repeatCount e imprimir el resultado
        
        // TODO: Llamar a format con el mensaje y el prefijo e imprimir el resultado
        
        // TODO: Llamar a format con el mensaje, el prefijo y el sufijo e imprimir el resultado
        
    }
}