Entendendo Interfaces em Java: Definições, Usos e Boas Práticas

Uma interface é um tipo de referência em Java. Semelhante a uma classe, é uma coleção de métodos abstratos. Uma classe implementa uma interface, herdando assim seus métodos abstratos.

Além de métodos abstratos, interface pode conter constantes, métodos default, métodos estáticos e tipos aninhados. Corpos de métodos existem apenas para métodos default e estáticos.

Escrever interface é semelhante a escrever classe. Mas classe descreve atributos e comportamentos de um objeto. Interface contém comportamentos que uma classe implementa.

A menos que a classe que implementa a interface seja abstrata, todos os métodos da interface precisam ser definidos na classe.

Semelhanças com Classe

• Interface pode conter qualquer número de métodos.
• Arquivo .java com nome igual ao da interface.
• Bytecode em arquivo .class.
• Interfaces aparecem em pacotes; bytecode deve estar em estrutura de diretórios que corresponda ao nome do pacote.

Diferenças em Relação a Classe

• Não se pode instanciar uma interface.
• Interface não contém construtores.
• Todos os métodos em interface são abstratos (implícito).
• Interface não pode conter campos de instância. Campos só podem ser static e final.
• Interface não é estendida por classe; é implementada por classe.
• Interface pode estender múltiplas interfaces.

Declarando Interfaces

Palavra-chave interface.

Exemplo Básico

/* File name: NameOfInterface.java */
import java.lang.*;

public interface NameOfInterface {
    // Qualquer número de campos static final
    // Qualquer número de declarações de métodos abstratos
}

Propriedades:

• Interface é implicitamente abstract; não precisa da palavra-chave.
• Cada método é implicitamente abstract; não precisa da palavra-chave.
• Métodos em interface são implicitamente public.

Exemplo: Animal

/* File name: Animal.java */
interface Animal {
    public void eat();
    public void travel();
}

Implementando Interfaces

Quando classe implementa interface, assina contrato concordando em realizar comportamentos específicos. Se não implementar todos, deve ser declarada abstrata.

Classe usa implements na declaração, após a parte extends.

Exemplo: MammalInt

/* File name: MammalInt.java */
public class MammalInt implements Animal {
    public void eat() {
        System.out.println("Mamífero come");
    }

    public void travel() {
        System.out.println("Mamífero viaja");
    }

    public int noOfLegs() { return 0; }

    public static void main(String args[]) {
        MammalInt m = new MammalInt();
        m.eat();
        m.travel();
    }
}

Saída:

Mamífero come
Mamífero viaja

Regras ao Sobrescrever Métodos de Interface

• Exceções checked não devem ser declaradas nos métodos de implementação, exceto as declaradas pelo método da interface ou subclasses delas.
• Assinatura e tipo de retorno (ou subtipo) devem ser mantidos.
• Classe de implementação pode ser abstrata; se for, métodos da interface não precisam ser implementados.

Regras de Implementação

• Classe pode implementar mais de uma interface ao mesmo tempo.
• Classe pode estender apenas uma classe, mas implementar muitas interfaces.
• Interface pode estender outra interface, similar a classe estender classe.

Estendendo Interfaces

Interface pode estender outra com extends; a interface filha herda métodos da pai.

Exemplo: Sports, Football, Hockey

// Filename: Sports.java
public interface Sports {
    public void setHomeTeam(String name);
    public void setVisitingTeam(String name);
}

// Filename: Football.java
public interface Football extends Sports {
    public void homeTeamScored(int points);
    public void visitingTeamScored(int points);
    public void endOfQuarter(int quarter);
}

// Filename: Hockey.java
public interface Hockey extends Sports {
    public void homeGoalScored();
    public void visitingGoalScored();
    public void endOfPeriod(int period);
    public void overtimePeriod(int ot);
}

Hockey tem 4 métodos próprios + 2 herdados de Sports = 6 métodos totais. Classe que implementa Hockey deve implementar todos os 6. Similar para Football (3 + 2 = 5).

Estendendo Múltiplas Interfaces

Classe Java só pode estender uma classe pai. Herança múltipla não permitida. Mas interfaces não são classes; uma interface pode estender mais de uma interface pai.

extends usado uma vez, interfaces pai em lista separada por vírgula.

public interface Hockey extends Sports, Event

Interfaces de Marcação (Tagging Interfaces)

Uso comum de estender interfaces ocorre quando a interface pai não contém métodos. Ex.: MouseListener em java.awt.event estende java.util.EventListener:

package java.util;
public interface EventListener { }

Interface sem métodos é tagging interface. Dois propósitos de design:

1. Cria pai comum — Como EventListener, estendida por dezenas de interfaces na API Java. Ao estender EventListener, JVM sabe que a interface será usada em cenário de delegação de eventos.
2. Adiciona tipo de dado a uma classe — Origem do termo "tagging". Classe que implementa tagging interface não define métodos (interface não tem), mas a classe torna-se um tipo de interface via polimorfismo.