Questão de Programação — Java — FGV 2023

Sobrecarga de métodos e conversão de tipos em Java

Gabarito: letra E. O código exibe int: 23 e double: 3.5956 porque há dois métodos com o mesmo nome imprimir, mas com assinaturas diferentes — um recebe int e outro recebe double. Na primeira chamada, o argumento 23 (literal inteiro) casa com o método int; na segunda, o argumento 3.5956 (literal decimal, que em Java é double) casa com o método double. Isso é sobrecarga de métodos (overloading), um polimorfismo estático resolvido em tempo de compilação.

A sobrecarga (overloading) é um dos dois tipos de polimorfismo em Java. O outro é a sobrescrita (overriding). A sobrecarga ocorre quando dois ou mais métodos têm o mesmo nome, mas assinaturas diferentes — ou seja, quantidade e/ou tipos de parâmetros distintos. O compilador decide qual método chamar analisando os argumentos passados na chamada. Isso é resolvido em tempo de compilação, por isso é chamado de polimorfismo estático ou ad-hoc. Já a sobrescrita ocorre quando uma subclasse redefine um método da superclasse, com a mesma assinatura, e a decisão de qual versão executar acontece em tempo de execução (polimorfismo dinâmico ou por inclusão).

No trecho da questão, temos dois métodos imprimir: um que recebe int e outro que recebe double. Quando o código chama imprimir(23), o literal 23 é um int, então o compilador seleciona o método que aceita int. Quando chama imprimir(3.5956), o literal 3.5956 é um double (em Java, todo literal de ponto flutuante é double por padrão), então o compilador seleciona o método que aceita double. Não há erro de sintaxe nem de execução — a sobrecarga é perfeitamente válida e o código compila e roda normalmente.

Um ponto que confunde muitos candidatos é pensar que a segunda chamada poderia ser convertida para float ou que o método int seria chamado com truncamento. Isso não acontece: o literal 3.5956 é double, e o compilador escolhe a versão mais específica compatível — que é exatamente o método double. Não há conversão implícita de double para int (isso seria um estreitamento, que exige cast explícito), então a chamada imprimir(3.5956) só pode casar com o método double. A saída reflete exatamente os tipos dos parâmetros: int: 23 e double: 3.5956.

A pegadinha da banca está em confundir sobrecarga com erro de sintaxe (alternativa A) ou com incompatibilidade de tipos (alternativa B). A sobrecarga é um recurso válido e comum em Java — ter dois métodos com o mesmo nome não é erro, desde que as assinaturas sejam diferentes. A alternativa C erra ao trocar o tipo da primeira saída para double (o literal 23 é int, não double), e a alternativa D erra ao trocar o tipo da segunda saída para int (o literal 3.5956 é double, e não há conversão implícita para int).

Guarde a distinção entre sobrecarga (mesmo nome, assinaturas diferentes, resolução em tempo de compilação) e sobrescrita (mesma assinatura, redefinição em subclasse, resolução em tempo de execução) — é exatamente nessa fronteira que as alternativas se dividem.

Alternativa A — ❌ Incorreta

Afirma que há erro de sintaxe por existirem dois métodos com o mesmo nome. Isso é falso: em Java, é perfeitamente válido ter métodos com o mesmo nome, desde que as assinaturas (tipos e/ou quantidade de parâmetros) sejam diferentes. Isso é sobrecarga (overloading), um recurso legítimo da linguagem. O código compila sem erro de sintaxe.

Alternativa B — ❌ Incorreta

Afirma que há erro de execução por incompatibilidade de tipos. Não há incompatibilidade: cada chamada casa exatamente com um dos métodos sobrecarregados. O literal 23 é int e casa com o método int; o literal 3.5956 é double e casa com o método double. Não há conversão implícita de double para int (isso exigiria cast explícito), mas também não é necessária — o método double existe e é selecionado.

Alternativa C — ❌ Incorreta

Apresenta a saída double: 23.0 para a primeira chamada. O literal 23 é um int, não um double. O compilador seleciona o método imprimir(int), que exibe int: 23. Para que a saída fosse double: 23.0, a chamada teria que ser imprimir(23.0) (literal double) ou o método int não existir e houvesse conversão implícita — o que não é o caso.

Alternativa D — ❌ Incorreta

Apresenta a saída int: 4 para a segunda chamada. O literal 3.5956 é um double, e não há conversão implícita de double para int (isso seria um estreitamento, que exige cast explícito e causaria perda de precisão). O compilador seleciona o método imprimir(double), que exibe double: 3.5956. A alternativa D confunde o tipo do literal e ignora a regra de seleção de sobrecarga.

Alternativa E — ✅ Correta ⟵ GABARITO

A saída correta é int: 23 e double: 3.5956. A primeira chamada imprimir(23) casa com o método imprimir(int) porque o literal 23 é int. A segunda chamada imprimir(3.5956) casa com o método imprimir(double) porque o literal 3.5956 é double (todo literal de ponto flutuante em Java é double por padrão). A sobrecarga resolve cada chamada pelo tipo do argumento, e a saída reflete exatamente os tipos dos parâmetros.

Gabarito: letra E