Dominando Interfaces em Java: Conceitos, Implementação e Boas Práticas

Interfaces em Java Explicadas

Interfaces em Java definem um contrato que classes implementadoras devem honrar. Elas permitem abstração, herança múltipla e promovem arquitetura limpa e modular.

Definindo uma Interface

Uma interface é um tipo totalmente abstrato. Todos seus métodos são implicitamente public abstract, e todos campos são public static final. É declarada com a palavra-chave interface:

interface Linguagem { void obterTipo(); void obterVersao(); }

Aqui, Linguagem é uma interface contendo dois métodos abstratos.

Implementando uma Interface

Interfaces não podem ser instanciadas. Classes as implementam usando a palavra-chave implements e fornecem corpos concretos para todos os métodos abstratos.

Exemplo 1: Interface Polígono

interface Poligono { void obterArea(int comprimento, int largura); } class Retangulo implements Poligono { @Override public void obterArea(int comprimento, int largura) { System.out.println("A área do retângulo é " + (comprimento * largura)); } } class Main { public static void main(String[] args) { Retangulo r = new Retangulo(); r.obterArea(5, 6); } }

Saída:

A área do retângulo é 30

Exemplo 2: Interface Linguagem

interface Linguagem { void obterNome(String nome); } class LinguagemProgramacao implements Linguagem { @Override public void obterNome(String nome) { System.out.println("Linguagem de Programação: " + nome); } } class Main { public static void main(String[] args) { LinguagemProgramacao lang = new LinguagemProgramacao(); lang.obterNome("Java"); } }

Saída:

Linguagem de Programação: Java

Implementando Múltiplas Interfaces

Uma classe pode implementar várias interfaces:

interface A { /* membros */ } interface B { /* membros */ } class C implements A, B { /* implementações */ }

Estendendo uma Interface

Interfaces podem estender outras interfaces usando extends:

interface Linha { /* membros */ } interface Poligono extends Linha { /* membros */ }

Uma classe que implementa Poligono deve fornecer métodos para membros de tanto Linha quanto Poligono.

Estendendo Múltiplas Interfaces

interface A { /* ... */ } interface B { /* ... */ } interface C extends A, B { /* ... */ }

Por Que Usar Interfaces?

• Abstração: Define operações sem ditar implementação, permitindo comportamento variado entre classes.
• Especificação: Estabelece contrato claro que classes implementadoras devem cumprir.
• Herança Múltipla: Permite que uma classe adote comportamentos de múltiplas fontes.
• Visibilidade Padrão: Todos métodos são implicitamente public; campos são public static final.

Exemplo de constantes implícitas:

interface Linguagem { String TIPO = "linguagem de programação"; // implicitamente public static final void obterNome(); // implicitamente public }

Métodos Default (Java 8+)

Java 8 introduziu métodos default, permitindo que interfaces contenham corpos de métodos concretos:

default void obterLados() { System.out.println("Posso obter lados de um polígono."); }

Métodos default permitem compatibilidade retroativa ao adicionar novos métodos a interfaces sem quebrar implementações existentes.

Exemplo: Uso de Método Default

interface Poligono { void obterArea(); default void obterLados() { System.out.println("Posso obter lados de um polígono."); } } class Retangulo implements Poligono { @Override public void obterArea() { int comprimento = 6; int largura = 5; int area = comprimento * largura; System.out.println("A área do retângulo é " + area); } @Override public void obterLados() { System.out.println("Tenho 4 lados."); } } class Quadrado implements Poligono { @Override public void obterArea() { int lado = 5; int area = lado * lado; System.out.println("A área do quadrado é " + area); } } class Main { public static void main(String[] args) { Retangulo r = new Retangulo(); r.obterArea(); r.obterLados(); Quadrado q = new Quadrado(); q.obterArea(); q.obterLados(); } }

Saída:

A área do retângulo é 30 Tenho 4 lados. A área do quadrado é 25 Posso obter lados de um polígono.

Métodos Static e Private (Java 9+)

Interfaces agora podem conter métodos static, chamáveis via nome da interface:

interface Poligono { static void auxiliar() { /* ... */ } } Poligono.auxiliar();

Métodos private fornecem utilitários internos para outros métodos da interface, garantindo encapsulamento.

Exemplo Prático: Cálculos de Polígono

import java.lang.Math; interface Poligono { void obterArea(); default void obterPerimetro(int... lados) { int perimetro = 0; for (int lado : lados) perimetro += lado; System.out.println("Perímetro: " + perimetro); } } class Triangulo implements Poligono { private final int a, b, c; private double area; Triangulo(int a, int b, int c) { this.a = a; this.b = b; this.c = c; } @Override public void obterArea() { double s = (a + b + c) / 2.0; area = Math.sqrt(s * (s - a) * (s - b) * (s - c)); System.out.println("Área: " + area); } } class Main { public static void main(String[] args) { Triangulo t = new Triangulo(2, 3, 4); t.obterArea(); t.obterPerimetro(2, 3, 4); } }

Saída:

Área: 2.9047375096555625 Perímetro: 9

Neste exemplo, a interface Poligono fornece um método obterPerimetro reutilizável, enquanto cada forma implementa seu próprio cálculo de área.