🎯 O que é uma interface em Java?

Uma interface é um contrato: define métodos que devem ser implementados por uma classe.
Ela não tem estado (variáveis de instância), e por padrão todos os métodos são public abstract, no Java 8 em diante, pode ter métodos default e static.

✍️Declarando uma interface

interface Animal {
  void emitirSom();
}

📜Implementando uma interface

class Cachorro implements Animal {
  @Override
  public void emitirSom() {
    System.out.println("Au au!");
  }
}

📜Estendendo interfaces

Interfaces podem herdar outras interfaces:

interface A {
  void metodoA();
}

interface B extends A {
  void metodoB();
}

class Classe implements B {
  @Override
  public void metodoA() {
    System.out.println("A");
  }

  @Override
  public void metodoB() {
    System.out.println("B");
  }
}

📜`@Override` annotation

Indica que um método está sendo sobrescrito.
Se você errar a assinatura do método, o compilador avisa.

interface Operacao {
  void executar();
}

class Soma implements Operacao {
  @Override
  public void executar() {
    System.out.println("Executando soma");
  }
}

❌ Se escrever errado:

@Override
public void executarr() { } 
//❌método não existe na interface

✅ Interface com `default` e `static`

interface Saudacao {
  default void ola() {
    System.out.println("Olá padrão");
  }

  static void oi() {
    System.out.println("Oi estático");
  }
}

🧩 Pegadinhas

🔸 1. `@Override` em métodos de interface:

interface Teste {
  void executar();
}

class X implements Teste {
  @Override
  public void executar() { } 
  // ✅ obrigatório implementar
}

🔸 2. Métodos de interface são sempre públicos.

Linha 2 abaixo é public abstract, mesmo que não esteja declarado
Linha 6 gera um erro pois precisa informar que é public se não considera o acesso como default access.

interface I {
  void m(); 
}

class C implements I {
  void m() { } 
}

🔸 3. Interface não pode ter construtor.

interface I {
  I() {} // ❌ ERRO
}

📘 Exemplo completo

interface Operacao {
  void executar();
  default void log() {
    System.out.println("Log padrão");
  }
}

class Soma implements Operacao {
  @Override
  public void executar() {
    System.out.println("Executando SOMA");
  }
}

📝 Quiz estilo 1Z0-809 (5 perguntas)

🧩Clique na pergunta para ver a resposta, tente fazer primeiro 🏋️‍♀️

1️⃣ Qual das seguintes declarações de interface é válida?

Gabarito: ✅ C
📌 Explicação: Métodos em interfaces são implicitamente public abstract, mesmo que você não escreva isso.

A) interface Teste { private void x(); }
B) interface Teste { public Teste(); }
C) interface Teste { void x(); }
D) interface Teste { protected void x(); }

2️⃣ Dado:

Gabarito: ✅ B — Não compila
📌 O método da interface é public, então a implementação também precisa ser public. Aqui está sem o modificador, o que gera erro de compilação.

interface A { void metodo(); }
class B implements A {
  //@Override
  void metodo() { System.out.println("B"); }
}

Esse código:

A) Compila com sucesso
B) Não compila, metodo() deveria ser public
C) Executa mas não imprime nada
D) Gera erro por @Override

3️⃣ Qual é verdadeira sobre interfaces?

Gabarito: ✅ C — Interfaces podem ter default e static desde o Java 8

📌 Isso é uma das grandes mudanças do Java 8. Interfaces agora podem ter:

Métodos default (com implementação)
Métodos static (com implementação)

❌ Mas não podem ter construtores nem variáveis de instância.

A) Podem ter campos de instância
B) Podem estender classes
C) Podem ter métodos static e default
D) Podem ter construtores

4️⃣ Dado:

Gabarito: D — B e C

interface X {
  default void show() {
    System.out.println("X");
  }
}
interface Y {
  default void show() {
    System.out.println("Y");
  }
}
class Z implements X, Y {
  // Qual implementação de show() é chamada?
}

O que é necessário para resolver o conflito?

Gabarito: D) B e C
📌 Quando duas interfaces têm métodos default com a mesma assinatura, a classe que implementa ambas é OBRIGADA a sobrescrever esse método.
Ela também pode indicar explicitamente qual usar, com:
@Override
public void show() {
X.super.show();
}

A) Nada, Java escolhe uma automaticamente
B) Z deve sobrescrever show()
C) Z deve declarar qual super usar
D) B e C

5️⃣ Dado:

Gabarito: ✅ A — “Soma” será impresso

interface Operacao {
  void executar();
}

class Soma implements Operacao {
  @Override
  public void executar() {
    System.out.println("Soma");
  }
}

O que será impresso se new Soma().executar(); for chamado?

Gabarito: ✅ A — “Soma” será impresso
📌 A chamada new Soma().executar(); executa corretamente e imprime “Soma”.

A) Soma
B) null
C) Nada
D) Erro de compilação

🧠 RESUMO: Interfaces e @Override

Recurso	Permitido em Interface?
Métodos `abstract`	✅ Sim (por padrão)
Métodos `default`	✅ Sim (desde Java 8)
Métodos `static`	✅ Sim (desde Java 8)
Construtores	❌ Não
Variáveis de instância	❌ Não
Estender outra interface	✅ Sim
Estender classe	❌ Não
Implementar múltiplas interfaces	✅ Sim
Conflito entre `default`	⚠️ Requer sobrescrita