1. O que é uma interface?
Se uma classe abstrata é a planta de uma casa, a interface é mais como um acordo ou “contrato” para executar determinados trabalhos. Por exemplo, se você chama um encanador, espera que ele consiga “consertar a torneira” e “eliminar o vazamento”. Como ele fará isso — não é algo com que você se preocupe; o que importa é o resultado. Em Java, uma interface é exatamente esse tipo de contrato: ela diz quais métodos devem ser implementados, mas não diz como.
Resumindo e indo direto ao ponto:
Interface é um tipo especial em Java que define um conjunto de métodos que as classes que a adotarem são obrigadas a implementar.
- Uma interface descreve apenas “o que fazer”, e não “como fazer”.
- Até o Java 8, interfaces não continham implementações de métodos.
- Uma interface é um contrato puro: se uma classe implementa a interface, ela deve implementar todos os seus métodos.
Por que isso é útil?
- É possível “atribuir” várias interfaces a uma classe — ou seja, dar a ela vários “papéis”.
- Permite construir arquiteturas flexíveis e extensíveis, nas quais as classes podem implementar diferentes capacidades.
- Interfaces são amplamente usadas na biblioteca padrão do Java (por exemplo, Comparable, Serializable, Runnable etc.).
2. Sintaxe de declaração de interface
Declarar uma interface em Java é muito simples. Para isso, usa-se a palavra‑chave interface. Até o Java 8, os métodos de uma interface eram considerados por padrão public abstract, mesmo que isso não fosse especificado explicitamente. Isso significa: o método deve ser implementado na classe que implementa a interface.
Exemplo de interface
public interface Movable {
void move(int x, int y);
}
- Aqui declaramos a interface Movable (pode ser traduzida como “movível” ou “capaz de se mover”).
- Dentro dela é declarado o método move(int x, int y). Não há corpo de método — apenas a assinatura. Este é o “contrato”: “se você implementar Movable, implemente move”.
Particularidades da sintaxe
- Métodos em interfaces não possuem corpo (até o Java 8).
- Todos os métodos de interface são, por padrão, public abstract (não é necessário escrever explicitamente).
- Uma interface pode conter apenas constantes (public static final), e não campos comuns.
Exemplo com constante
public interface Constants {
int MAX_SPEED = 100; // public static final por padrão
}
3. Diferença entre interface e classe
Interface não é classe! Vamos entender qual é a diferença.
| Classe (inclusive abstrata) | Interface |
|---|---|
| Pode conter campos (estado) | Não pode conter campos (apenas constantes) |
| Pode conter implementação de métodos | Até o Java 8, interfaces não podiam conter implementação, apenas assinaturas |
| Pode ser instanciada com new (se não for abstrata) | Não pode ser criada diretamente |
| Herança única (extends) | Uma classe pode implementar várias interfaces (implements) |
| Usada para “o que isto é” | Usada para “o que sabe fazer” |
A classe implementa a interface usando implements
public class Robot implements Movable {
@Override
public void move(int x, int y) {
System.out.println("O robô se move para o ponto (" + x + ", " + y + ")");
}
}
- A classe Robot implementa a interface Movable.
- A palavra‑chave implements — “implementa”.
- É obrigatório implementar todos os métodos da interface (caso contrário haverá erro de compilação).
- Não se esqueça da anotação @Override — ela não é obrigatória, mas ajuda o compilador e você a evitar erros.
4. Exemplo de uso de interface
Vamos escrever um exemplo simples para ver como isso funciona na prática. Suponha que temos a interface Movable e queremos que diferentes classes “se movam”: um robô, um carro, um animal...
Etapa 1. Declaramos a interface
public interface Movable {
void move(int x, int y);
}
Etapa 2. Implementamos a interface na classe
public class Robot implements Movable {
@Override
public void move(int x, int y) {
System.out.println("O robô se desloca para o ponto (" + x + ", " + y + ")");
}
}
Etapa 3. Usamos a interface
public class Main {
public static void main(String[] args) {
Movable m = new Robot(); // Variável do tipo interface!
m.move(10, 20); // Imprimirá: O robô se desloca para o ponto (10, 20)
}
}
Atenção
- Podemos declarar uma variável do tipo interface (Movable m) e atribuir a ela um objeto de uma classe que implementa essa interface (new Robot()).
- Isso permite escrever código genérico que funciona com qualquer objeto “movível”, sem saber de qual classe ele realmente é.
Erro de compilação se o método não for implementado
Error: Class 'Robot' must either be declared abstract or implement abstract method 'move(int, int)' in 'Movable'
Essa é a força das interfaces — elas garantem que todas as classes que as implementam terão os métodos necessários.
5. Interfaces na biblioteca padrão do Java
Interfaces não são apenas um tema “escolar”. Elas são usadas ativamente em toda a biblioteca padrão do Java. Aqui vão alguns exemplos:
- Comparable<T> — interface para comparar objetos (por exemplo, em ordenações).
- Runnable — interface para iniciar uma thread.
- Serializable — interface de marcação que indica que o objeto pode ser serializado.
- List, Set, Map — interfaces de coleções.
Exemplo: Comparable
public class Person implements Comparable<Person> {
String name;
int age;
// Construtor e outros métodos...
@Override
public int compareTo(Person other) {
return this.age - other.age;
}
}
Agora objetos Person podem ser ordenados, porque implementam a interface Comparable.
6. Esquema visual: como uma interface funciona
+-------------------+ +-------------------+
| interface | | class |
| Movable |<--------| Robot |
|-------------------| |-------------------|
| +move(int, int) | | +move(int, int) |
+-------------------+ +-------------------+
- A seta mostra que a classe Robot implementa a interface Movable.
- A interface define apenas “o que deve existir”; a classe define “como isso funciona”.
Analogia do mundo real
Uma interface em Java é como uma carteira de motorista. Se você tem a carteira (você implementa a interface “Motorista”), então você sabe dirigir um carro. Como exatamente você faz isso são detalhes: alguns dirigem com cuidado, outros rapidamente, mas o importante é que você se comprometeu a saber fazer isso.
7. Exemplo prático: continuando nosso aplicativo
public interface Movable {
void move(int x, int y);
}
public class Animal implements Movable {
protected String name;
public Animal(String name) {
this.name = name;
}
@Override
public void move(int x, int y) {
System.out.println(name + " se desloca para o ponto (" + x + ", " + y + ")");
}
}
public class Robot implements Movable {
private String model;
public Robot(String model) {
this.model = model;
}
@Override
public void move(int x, int y) {
System.out.println("O robô " + model + " vai para as coordenadas (" + x + ", " + y + ")");
}
}
public class Main {
public static void main(String[] args) {
Movable[] movables = {
new Animal("Barsik"),
new Robot("R2D2")
};
for (Movable m : movables) {
m.move(5, 10);
}
}
}
Resultado:
Barsik se desloca para o ponto (5, 10)
O robô R2D2 vai para as coordenadas (5, 10)
Criamos um array de objetos do tipo Movable. Nele podem existir quaisquer objetos que implementem essa interface! O código no laço não sabe quem exatamente está à sua frente — um animal ou um robô —, mas sabe que cada um deles sabe move.
8. Erros comuns ao trabalhar com interfaces
Erro nº 1: tentar criar um objeto de interface diretamente. Interface é um contrato, não um objeto concreto. Não é possível escrever new Movable() — isso causará um erro de compilação. É necessário criar objetos de classes que implementam a interface.
Erro nº 2: nem todos os métodos da interface foram implementados. Se a classe implementa a interface, mas não implementa todos os seus métodos, o compilador emitirá um erro: “Class must either be declared abstract or implement abstract method ...”. Se você não quiser implementar todos os métodos, declare a classe como abstract.
Erro nº 3: esquecer os modificadores de acesso. Métodos de interface são sempre public (mesmo que isso não esteja escrito explicitamente). Na classe que implementa, não é permitido reduzir o nível de acesso; portanto, o método também deve ser public.
Erro nº 4: tentar adicionar campos comuns à interface. Em uma interface, só é possível declarar constantes (public static final). Campos comuns (não estáticos) não podem ser adicionados.
GO TO FULL VERSION