Java POO Intermediário

Interfaces

Uma interface em Java é um contrato que define um conjunto de métodos que uma classe deve implementar. Ela permite que classes diferentes compartilhem um mesmo tipo, sem herdar código, promovendo polimorfismo e baixo acoplamento. A partir do Java 8, interfaces podem ter métodos default (com implementação) e métodos estáticos, e podem ser usadas como interfaces funcionais (com um único método abstrato) para expressões lambda.

Diferente de uma classe abstrata, uma interface não pode ter estado (atributos de instância) nem construtores, e uma classe pode implementar múltiplas interfaces, enquanto só pode estender uma classe. Use interfaces quando quiser definir um papel ou contrato que várias classes podem assumir; use classes abstratas quando quiser compartilhar código e estado entre classes relacionadas.

Neste card, você verá como declarar e implementar interfaces, criar métodos default, usar @FunctionalInterface com lambdas e comparar interfaces com classes abstratas.

Pontos-chave

implements é usado por uma classe para assumir o contrato de uma interface.
Métodos default em interfaces fornecem implementação padrão sem quebrar classes existentes.
Interfaces funcionais têm exatamente um método abstrato e podem ser usadas com lambdas.
Interfaces permitem herança múltipla de tipo; classes abstratas permitem herança simples de código e estado.
Uma classe pode implementar várias interfaces, mas estender apenas uma classe.

ExemploInterfaces.java

// Interface funcional: um único método abstrato
@FunctionalInterface
interface Saudacao {
    String cumprimentar(String nome);

    // Método default: implementação padrão
    default String cumprimentarFormal(String nome) {
        return "Prezado(a) " + nome;
    }
}

// Interface com método default
interface Calculadora {
    int somar(int a, int b);

    default int somarTres(int a, int b, int c) {
        return somar(somar(a, b), c);
    }
}

// Classe que implementa duas interfaces
class MinhaCalculadora implements Calculadora, Saudacao {
    @Override
    public int somar(int a, int b) {
        return a + b;
    }

    @Override
    public String cumprimentar(String nome) {
        return "Olá, " + nome + "!";
    }
}

public class ExemploInterfaces {
    public static void main(String[] args) {
        MinhaCalculadora calc = new MinhaCalculadora();

        // Usando método abstrato implementado
        System.out.println("Soma: " + calc.somar(2, 3));

        // Usando método default da interface Calculadora
        System.out.println("Soma de três: " + calc.somarTres(1, 2, 3));

        // Usando método default da interface Saudacao
        System.out.println(calc.cumprimentarFormal("Maria"));

        // Interface funcional com lambda
        Saudacao lambda = nome -> "E aí, " + nome + "?";
        System.out.println(lambda.cumprimentar("João"));
    }
}

Interfaces

Pontos-chave

Exercícios

Implementando uma interface simples

Métodos default e interface funcional

Interface vs classe abstrata e herança múltipla de tipo

Continue estudando