Interfaces em Java: definindo contratos e implements

Uma interface é um contrato

Uma interface declara o que uma classe pode fazer sem dizer como. É uma lista de assinaturas de métodos que qualquer classe que a implemente promete cumprir. O ponto central é o desacoplamento: o código pode trabalhar com o tipo da interface sem se importar com qual classe concreta está por trás.

interface Shape {
    double area();          // toda Shape precisa fornecer uma area
    double perimeter();
}

class Circle implements Shape {
    private final double radius;

    Circle(double radius) { this.radius = radius; }

    public double area() { return Math.PI * radius * radius; }
    public double perimeter() { return 2 * Math.PI * radius; }
}

public class Main {
    public static void main(String[] args) {
        Shape s = new Circle(2.0);
        System.out.printf("area %.2f, perimeter %.2f%n", s.area(), s.perimeter());
    }
}

Circle implements Shape significa que Circle precisa definir area e perimeter. Quando o faz, um Circle é uma Shape e pode ser armazenado em uma variável do tipo Shape.

Muitas classes, um único tipo

O poder fica evidente quando várias classes sem relação entre si implementam a mesma interface. O código escrito contra Shape lida com todas elas:

import java.util.List;

interface Shape {
    double area();
}

class Circle implements Shape {
    private final double r;
    Circle(double r) { this.r = r; }
    public double area() { return Math.PI * r * r; }
}

class Rectangle implements Shape {
    private final double w, h;
    Rectangle(double w, double h) { this.w = w; this.h = h; }
    public double area() { return w * h; }
}

public class Main {
    public static void main(String[] args) {
        List<Shape> shapes = List.of(new Circle(1), new Rectangle(2, 3), new Circle(2));

        double total = 0;
        for (Shape shape : shapes) {
            total += shape.area();   // funciona para toda Shape, qualquer que seja sua classe
        }
        System.out.printf("total area: %.2f%n", total);
    }
}

O laço nunca pergunta "isto é um Circle ou um Rectangle?" - ele apenas chama area() e confia no contrato. Adicionar um Triangle mais tarde não exige nenhuma mudança aqui.

Implementando múltiplas interfaces

Uma classe estende apenas uma classe, mas pode implementar qualquer número de interfaces - é assim que Java realiza a "herança múltipla" de comportamento com segurança:

interface Drawable { void draw(); }
interface Resizable { void resize(double factor); }

class Sprite implements Drawable, Resizable {
    private double scale = 1.0;

    public void draw() { System.out.println("drawing at scale " + scale); }
    public void resize(double factor) { scale *= factor; }
}

public class Main {
    public static void main(String[] args) {
        Sprite s = new Sprite();
        s.resize(2.0);
        s.draw();
    }
}

Liste as interfaces separadas por vírgula após implements. A classe precisa satisfazer todas elas.

Métodos default e static

Desde o Java 8, uma interface pode incluir corpos de método. Um método default dá às classes que a implementam uma implementação pronta que elas herdam de graça (e podem sobrescrever):

interface Greeter {
    String name();

    default String greet() {        // implementação compartilhada
        return "Hello, " + name();
    }
}

class English implements Greeter {
    public String name() { return "world"; }
    // greet() é herdado da interface
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new English().greet());
    }
}

Métodos default permitem que uma interface evolua - adicionando um método sem quebrar todos os implementadores existentes. Um método de interface static, por outro lado, é um utilitário que você chama na própria interface, como Comparator.naturalOrder().

Constantes

Os campos de uma interface são implicitamente public static final - são constantes, não estado de instância:

interface Physics {
    double GRAVITY = 9.81;   // automatically public static final
}

As interfaces tradicionalmente não guardam estado por objeto; a ausência de campos de instância é parte do que as distingue das classes.

Interfaces funcionais

Uma interface com exatamente um método abstrato é uma interface funcional, e você pode implementá-la com uma expressão lambda em vez de uma classe inteira:

interface Transformer {
    int apply(int x);
}

public class Main {
    public static void main(String[] args) {
        Transformer doubler = x -> x * 2;     // o lambda implementa o único método
        System.out.println(doubler.apply(21));
    }
}

Esta é a base dos lambdas de Java e dos tipos de java.util.function (Function, Predicate, Supplier e companhia). A anotação @FunctionalInterface torna a intenção explícita e permite que o compilador imponha a regra de método único.

Interface versus classe abstrata

Ambas permitem programar contra uma abstração, então quando escolher cada uma?

• Interface - uma capacidade que classes sem relação entre si podem compartilhar. Um Bird e um Airplane podem ambos ser Flyable. Uma classe pode implementar muitas. Sem estado de instância.
• Classe abstrata - estado e código compartilhados entre classes intimamente relacionadas. Um Cat e um Dog ambos estendem Animal, herdando campos comuns e métodos parcialmente implementados. Uma classe estende apenas uma.

Um padrão comum combina as duas: uma interface define o contrato e uma classe abstrata implementa as partes repetitivas, de modo que as subclasses concretas preenchem apenas os detalhes específicos.

A seguir: classes abstratas

As interfaces definem comportamento sem estado. As classes abstratas ficam entre as interfaces e as classes completas - elas podem declarar métodos não implementados e carregar campos e construtores. Esse é o tema da próxima página.