Questão de Programação — Programação Orientada a Objetos — INSTITUTO AOCP 2025

Sobrecarga de Métodos e Ambiguidade em Java

Gabarito: letra A. O código apresenta erro de compilação por ambiguidade: ao chamar exibir(null), o compilador não consegue decidir entre exibir(Integer) e exibir(double), pois null é compatível com o tipo referência Integer e também pode ser convertido (via unboxing) para o tipo primitivo double. Essa é uma regra clássica de resolução de sobrecarga em Java, prevista na especificação da linguagem (JLS).

A sobrecarga de métodos (overload) é um dos pilares do polimorfismo estático em Java: permite que uma classe tenha vários métodos com o mesmo nome, mas com listas de parâmetros diferentes. O compilador escolhe qual método invocar com base nos argumentos passados na chamada. Quando há apenas um método compatível, a escolha é trivial. O problema surge quando existem dois ou mais métodos igualmente aplicáveis — e é exatamente isso que ocorre aqui.

No trecho, temos dois métodos sobrecarregados: exibir(Integer) e exibir(double). A chamada exibir(null) é ambígua porque null é um valor especial que pode ser atribuído a qualquer tipo referência (como Integer) e, por meio de unboxing, também pode ser convertido para um tipo primitivo (como double). O compilador Java, ao resolver a sobrecarga, segue uma ordem de precedência: primeiro tenta a fase de aplicação estrita (sem boxing/unboxing), depois a fase de aplicação por boxing/unboxing e, por fim, a fase de aplicação por varargs. Neste caso, Integer é aplicável na primeira fase (null é um literal de referência), e double é aplicável na segunda fase (via unboxing de Double para double). Como ambos os métodos são aplicáveis em fases diferentes, e a fase 1 tem precedência sobre a fase 2, o compilador deveria escolher exibir(Integer). No entanto, a especificação da linguagem Java (JLS 15.12.2) determina que, se houver mais de um método aplicável na fase mais específica, e nenhum for mais específico que o outro, ocorre erro de compilação por ambiguidade. Aqui, exibir(Integer) e exibir(double) não são comparáveis em termos de especificidade: Integer é um tipo referência e double é um tipo primitivo, e não há relação de subtipo entre eles. Portanto, o compilador não consegue decidir e gera o erro.

Na prática, esse é um erro comum em Java, e a solução é evitar chamadas ambíguas, por exemplo, fazendo um cast explícito: exibir((Integer) null) ou exibir((double) 0). A banca explora exatamente esse conhecimento técnico: a diferença entre tipos primitivos e wrappers, e como o compilador resolve sobrecargas.

Guarde o critério decisivo: a ambiguidade ocorre quando dois métodos sobrecarregados são igualmente aplicáveis e não há um mais específico. É essa regra que separa as alternativas corretas das incorretas.

Alternativa A — ✅ Correta ⟵ GABARITO

A alternativa afirma que o código apresenta erro de compilação por ambiguidade, pois o compilador não consegue decidir entre exibir(Integer) e exibir(double) para o argumento null. Isso está correto. Como explicado, null é compatível com Integer (tipo referência) e, via unboxing, com double (tipo primitivo). Como nenhum dos dois métodos é mais específico que o outro, o compilador não consegue resolver a sobrecarga e gera erro de compilação. Essa é a regra da JLS para resolução de sobrecarga.

Alternativa B — ❌ Incorreta

Afirma que exibir(double) não pode ser sobrecarregado com exibir(Integer), pois Integer é um tipo primitivo e double é um wrapper. O erro está na inversão dos conceitos: Integer é um wrapper (classe que encapsula o primitivo int), e double é um tipo primitivo. Além disso, a sobrecarga entre um tipo primitivo e um wrapper é perfeitamente válida em Java — o que causa o erro não é a sobrecarga em si, mas a chamada ambígua com null.

Alternativa C — ❌ Incorreta

Afirma que o código compila e executa normalmente, imprimindo "Valor inteiro: null". Isso é falso: o código não compila, pois há erro de ambiguidade na chamada exibir(null). Se não houvesse ambiguidade (por exemplo, se só existisse exibir(Integer)), a saída seria "Valor inteiro: null", mas com os dois métodos sobrecarregados, o compilador rejeita o código.

Alternativa D — ❌ Incorreta

Afirma que o método main está incorreto, pois não é permitido passar valores null para métodos sobrecarregados. Isso é falso: é perfeitamente permitido passar null para métodos sobrecarregados, desde que não haja ambiguidade. O problema não está no main, mas na resolução da sobrecarga. Se houvesse apenas um método compatível, null seria aceito normalmente.

Alternativa E — ❌ Incorreta

Afirma que o compilador converte automaticamente null para double, e o método exibir(double) é executado com valor 0.0. Isso é falso: null não pode ser convertido para double (nem para qualquer tipo primitivo) sem gerar erro. A conversão de null para um tipo primitivo resultaria em NullPointerException em tempo de execução, mas aqui o problema ocorre antes, em tempo de compilação, devido à ambiguidade. O compilador não escolhe automaticamente double; ele simplesmente não consegue decidir.

Gabarito: letra A