Java: interfaces e métodos abstratos
Gabarito: letra D. O trecho de código apresenta uma interface (primeira lacuna) que declara um método abstrato adicao (segunda lacuna), o qual é implementado por uma classe que o sobrescreve com executar (terceira lacuna). A alternativa D é a única que preenche corretamente as três lacunas, pois interface é o tipo que declara contratos, adicao é o nome do método abstrato e executar é o nome do método concreto que o implementa.
Em Java, uma interface é um tipo de referência que define um contrato de métodos abstratos (sem corpo) que as classes devem implementar. Diferente de uma class, que pode ter implementação concreta de métodos e estado (atributos), a interface apenas declara o que deve ser feito, não como. Quando uma classe implementa uma interface, ela é obrigada a fornecer a implementação de todos os seus métodos abstratos, a menos que seja abstrata.
A sintaxe básica de uma interface em Java é:
interface NomeDaInterface {
// métodos abstratos (sem corpo)
tipoRetorno nomeDoMetodo(parametros);
}
E a implementação por uma classe:
class NomeDaClasse implements NomeDaInterface {
@Override
public tipoRetorno nomeDoMetodo(parametros) {
// corpo do método
}
}
No trecho da questão, a primeira lacuna deve ser preenchida com interface, pois o código declara um tipo que contém um método sem corpo (abstrato). A segunda lacuna é o nome desse método abstrato, que é adicao. A terceira lacuna é o nome do método concreto que implementa o contrato, que é executar. A alternativa D é a única que segue essa lógica.
A pegadinha da banca está em confundir interface com class e inverter a ordem dos nomes dos métodos. Muitos candidatos podem marcar a alternativa A (class - adicao - executar) por pensar que se trata de uma classe comum, mas a presença de um método sem corpo (abstrato) indica que é uma interface. Além disso, a ordem dos nomes é crucial: primeiro o método abstrato declarado na interface, depois o método concreto que o implementa.
Alternativa A — ❌ Incorreta
A alternativa A preenche a primeira lacuna com class, o que está errado. O trecho declara um método sem corpo (abstrato), característica de interface, não de class. Uma classe pode ter métodos abstratos, mas para isso deve ser declarada como abstract class, o que não é o caso. Além disso, a ordem adicao - executar está correta, mas o tipo errado invalida a alternativa.
Alternativa B — ❌ Incorreta
A alternativa B também usa class na primeira lacuna, o que é incorreto pelo mesmo motivo da alternativa A. Além disso, inverte a ordem dos métodos: coloca executar antes de adicao. Na interface, o método abstrato é adicao, e a classe que implementa usa executar. A inversão torna a alternativa errada.
Alternativa C — ❌ Incorreta
A alternativa C usa class na primeira lacuna, incorreto. Além disso, o segundo nome Op não corresponde ao método abstrato declarado, que é adicao. O terceiro nome adicao também está errado, pois o método concreto que implementa o contrato é executar. A alternativa mistura nomes que não se encaixam no código.
Alternativa D — ✅ Correta ⟵ GABARITO
A alternativa D preenche corretamente as três lacunas: interface (tipo que declara o contrato), adicao (método abstrato) e executar (método concreto que implementa). Essa é a sequência lógica e sintaticamente correta para o trecho de código Java apresentado.
Alternativa E — ❌ Incorreta
A alternativa E usa interface corretamente na primeira lacuna, mas inverte a ordem dos métodos: coloca executar antes de adicao. Na interface, o método abstrato é adicao, e a classe que implementa usa executar. A inversão torna a alternativa errada.
Gabarito: letra D — a única que preenche corretamente as lacunas com interface, adicao e executar.
