Entendendo a Sobrecarga de Métodos em Java (Method Overloading)

A sobrecarga de métodos é um recurso da linguagem Java que permite a uma classe ter múltiplos métodos com o mesmo nome, desde que suas listas de parâmetros sejam distintas. Essa técnica aumenta a legibilidade e a flexibilidade do código, permitindo que um nome de método seja usado para operações conceitualmente semelhantes.

A Regra Fundamental: A Assinatura do Método

A distinção entre métodos sobrecarregados é feita com base em sua assinatura, que em Java consiste no nome do método e na lista de parâmetros. Para que a sobrecarga seja válida, a lista de parâmetros de métodos com o mesmo nome deve ser diferente em pelo menos um dos seguintes aspectos:

• Diferente número de parâmetros.
• Diferente tipo dos parâmetros.
• Diferente ordem dos parâmetros.

Durante a compilação, o Java analisa os argumentos fornecidos em uma chamada de método e seleciona a versão sobrecarregada que corresponde exatamente àquela assinatura.

O exemplo a seguir demonstra as formas válidas de sobrecarga para um método sum:

public class Program{

    public static void main(String[] args) {

        System.out.println(sum(2, 3));          // Chama (1): sum(int, int)
        System.out.println(sum(4.5, 3.2));      // Chama (2): sum(double, double)
        System.out.println(sum(4, 3, 7));       // Chama (3): sum(int, int, int)
    }

    // (1) Sobrecarga com dois parâmetros do tipo int
    static int sum(int x, int y) {
        return x + y;
    }

    // (2) Sobrecarga com tipos diferentes (double)
    static double sum(double x, double y) {
        return x + y;
    }

    // (3) Sobrecarga com três parâmetros do tipo int
    static int sum(int x, int y, int z) {
        return x + y + z;
    }
}

O Tipo de Retorno Não Influencia a Sobrecarga

É crucial entender que o tipo de retorno não faz parte da assinatura do método para fins de sobrecarga. Tentar declarar dois métodos com a mesma assinatura (mesmo nome e mesma lista de parâmetros), mas com tipos de retorno diferentes, resultará em um erro de compilação.

Isso ocorre porque, ao chamar o método, o compilador não teria como saber qual versão executar, criando uma ambiguidade.

O código a seguir é inválido e não será compilado:

public class Program {

    public static void main(String[] args) {
        // AMBIGUIDADE: O compilador não sabe qual método chamar.
        // O valor de retorno não é usado para resolver a chamada.
        sum(2, 3);
    }

    static int sum(int x, int y) {
        return x + y;
    }

    // ERRO DE COMPILAÇÃO: assinatura 'sum(int, int)' já definida na classe.
    static double sum(int x, int y) {
        return x + y;
    }
}

O compilador sinalizará um erro porque o método sum(int, int) já foi definido, e a simples alteração do tipo de retorno de int para double não é suficiente para criar uma sobrecarga válida.

📝 Exercícios

Tarefa: Criando Métodos Sobrecarregados

Complete a classe Display criando as duas versões sobrecarregadas do método print para que o código no método main funcione sem erros.

public class Display {
    public static void main(String[] args) {
        // As chamadas abaixo devem funcionar após sua implementação
        print(100);             // Saída esperada: "Printing number: 100"
        print("Hello, world!"); // Saída esperada: "Printing text: Hello, world!"
    }

    // CRIE OS DOIS MÉTODOS 'print' SOBRECARREGADOS AQUI

}

public class Display {
    public static void main(String[] args) {
        print(100);
        print("Hello, world!");
    }

    static void print(int number) {
        System.out.println("Printing number: " + number);
    }

    static void print(String text) {
        System.out.println("Printing text: " + text);
    }
}