🎯 Interfaces

Contratos, Implementação Múltipla e Polimorfismo Avançado

1. O que é uma Interface?

Uma interface é um contrato que define um conjunto de métodos que uma classe deve implementar. Ela estabelece o que fazer, mas não como fazer.

Interfaces são ferramentas poderosas para criar código desacoplado, reutilizável e flexível.

Uma classe pode implementar múltiplas interfaces, o que oferece máxima flexibilidade e evita o problema da herança múltipla.

2. Características das Interfaces

Contrato

Define quais métodos uma classe deve implementar, sem especificar como.

Públicas

Todos os métodos de uma interface são implicitamente public.

Múltiplas Implementações

Uma classe pode implementar várias interfaces simultaneamente.

Polimorfismo

Diferentes classes implementam a mesma interface e podem ser usadas intercambiavelmente.

3. Sintaxe de uma Interface

java

// Definindo uma Interface
public interface Animal {
    // Método abstrato (sem corpo)
    void fazer_som();
    
    // Método com corpo (default method - Java 8+)
    default void dormir() {
        System.out.println("Zzzzz...");
    }
    
    // Constante (implicitamente final e static)
    int NUMERO_DE_PATAS = 4;
}

// Implementando a interface
public class Cachorro implements Animal {
    @Override
    public void fazer_som() {
        System.out.println("Au au!");
    }
    
    @Override
    public void dormir() {
        System.out.println("Cachorro dormindo...");
    }
}

// Uso
public class Main {
    public static void main(String[] args) {
        Animal dog = new Cachorro();
        dog.fazer_som();  // Au au!
        dog.dormir();     // Cachorro dormindo...
    }
}

4. Implementação Múltipla

Uma das maiores vantagens das interfaces é que uma classe pode implementar várias interfaces, oferecendo máxima flexibilidade.

java

// Múltiplas interfaces
public interface Terrestre {
    void andar();
}

public interface Aquatico {
    void nadar();
}

public interface Aereo {
    void voar();
}

// Classe implementa múltiplas interfaces
public class Pato implements Terrestre, Aquatico, Aereo {
    @Override
    public void andar() {
        System.out.println("Pato andando...");
    }
    
    @Override
    public void nadar() {
        System.out.println("Pato nadando...");
    }
    
    @Override
    public void voar() {
        System.out.println("Pato voando...");
    }
}

// Uso
public class Main {
    public static void main(String[] args) {
        Pato pato = new Pato();
        pato.andar();  // Pato andando...
        pato.nadar();  // Pato nadando...
        pato.voar();   // Pato voando...
    }
}

5. Polimorfismo com Interfaces

Uma das maiores vantagens das interfaces é permitir polimorfismo - diferentes classes implementam a mesma interface e podem ser usadas de forma intercambiável.

java

// Interface define o contrato
public interface Veiculo {
    void acelerar();
    void frear();
}

// Diferentes implementações
public class Carro implements Veiculo {
    @Override
    public void acelerar() {
        System.out.println("Carro acelerou - Vrummm!");
    }
    
    @Override
    public void frear() {
        System.out.println("Carro freou");
    }
}

public class Moto implements Veiculo {
    @Override
    public void acelerar() {
        System.out.println("Moto acelerou - Rooooom!");
    }
    
    @Override
    public void frear() {
        System.out.println("Moto freou");
    }
}

// Polimorfismo em ação
public class Garagem {
    public static void testar(Veiculo v) {
        v.acelerar();
        v.frear();
    }
    
    public static void main(String[] args) {
        Veiculo[] veiculos = {
            new Carro(),
            new Moto()
        };
        
        for (Veiculo v : veiculos) {
            testar(v);  // Polimorfismo!
        }
    }
}

6. Exemplo Prático: Sistema de Pagamento

Vamos criar um sistema que aceita múltiplas formas de pagamento usando interfaces:

java

public interface FormaPagamento {
    void processar(double valor);
    String obterNome();
}

public class CartaoCredito implements FormaPagamento {
    private String numero;
    
    public CartaoCredito(String numero) {
        this.numero = numero;
    }
    
    @Override
    public void processar(double valor) {
        System.out.println("💳 Cartão: " + numero);
        System.out.println("   Valor: R$ " + valor);
        System.out.println("   ✓ Aprovado!");
    }
    
    @Override
    public String obterNome() {
        return "Cartão de Crédito";
    }
}

public class Pix implements FormaPagamento {
    private String chave;
    
    public Pix(String chave) {
        this.chave = chave;
    }
    
    @Override
    public void processar(double valor) {
        System.out.println("📱 PIX para: " + chave);
        System.out.println("   Valor: R$ " + valor);
        System.out.println("   ✓ Realizado!");
    }
    
    @Override
    public String obterNome() {
        return "PIX";
    }
}

// Uso
public class Caixa {
    public static void processar(FormaPagamento metodo, double valor) {
        System.out.println("--- " + metodo.obterNome() + " ---");
        metodo.processar(valor);
    }
    
    public static void main(String[] args) {
        processar(new CartaoCredito("1234-5678"), 150.00);
        processar(new Pix("email@exemplo.com"), 200.00);
    }
}

7. Default Methods (Java 8+)

A partir do Java 8, interfaces podem ter métodos com implementação padrão usando a palavra-chave default. Isso permite adicionar novos métodos sem quebrar classes existentes.

java

public interface Notificacao {
    void enviar(String mensagem);
    
    // Default method - tem implementação
    default void registrarLog(String msg) {
        System.out.println("[LOG] " + msg);
    }
    
    // Static method - pertence à interface
    static void info() {
        System.out.println("Sistema de notificações v1.0");
    }
}

public class EmailNotificacao implements Notificacao {
    @Override
    public void enviar(String mensagem) {
        System.out.println("📧 Email: " + mensagem);
        registrarLog("Email enviado");
    }
}

public class Main {
    public static void main(String[] args) {
        Notificacao.info();
        
        Notificacao email = new EmailNotificacao();
        email.enviar("Olá!");
    }
}

✅ Vantagens dos Default Methods:

Adicionar novos métodos sem quebrar código legado
Fornecer implementações padrão opcionais
Manter retrocompatibilidade

8. Interfaces vs Classes Abstratas

Use Classe Abstrata quando:

Há hierarquia clara de classes
Compartilhamento de código e estado
Modificadores de acesso diversos
Exemplo: Animal → Cachorro, Gato

Use Interface quando:

Classes sem relacionamento compartilham comportamento
Máxima flexibilidade e desacoplamento
Implementação múltipla necessária
Exemplo: Ligavel (Microondas, TV, Carro)

9. Exercícios Práticos

Exercício 1: Sistema de Reprodução

Crie interface Reprodutor com métodos play(), pause(), stop(). Implemente em Musica, Video e Podcast.

Exercício 2: Formas Geométricas

Crie interface Forma com métodos calcularArea() e calcularPerimetro(). Implemente em Circulo, Quadrado e Triangulo.

Exercício 3: Múltiplas Interfaces

Crie interfaces Persistivel (salvar/carregar) e Validavel (validar). Implemente ambas em uma classe Usuario.

Exercício 4: Sistema de Dispositivos

Crie interface Ligavel (ligar/desligar). Implemente em Microondas, TV, Computador e Refrigerador.

10. Resumo - Os 4 Pilares da POO

1. Encapsulamento

Protege dados com private, controla acesso com getters/setters.

2. Herança

Reutiliza código criando relacionamentos hierárquicos entre classes.

3. Polimorfismo

Um mesmo método com múltiplos comportamentos (sobrecarga e sobrescrita).

4. Abstração

Esconde complexidade, mostra apenas o essencial (classes abstratas e interfaces).

Conclusão

Interfaces são fundamentais para criar código orientado a objetos profissional, flexível e maintível.

Elas definem contratos de comportamento, permitindo que diferentes classes forneçam suas próprias implementações.

✓ Interfaces definem o QUÊ, não o COMO
✓ Uma classe pode implementar múltiplas interfaces
✓ Interfaces promovem polimorfismo e desacoplamento
✓ Default methods adicionam funcionalidade sem quebrar código
✓ Escolha interfaces para máxima flexibilidade

🚀 Domine interfaces e você dominará o design orientado a objetos!