Interfaces en Java: definir contratos e implements

Una interfaz es un contrato

Una interfaz declara qué puede hacer una clase sin decir cómo. Es una lista de firmas de métodos que cualquier clase que la implemente promete cumplir. La clave es el desacoplamiento: el código puede trabajar con el tipo de la interfaz sin importarle qué clase concreta hay detrás.

interface Shape {
    double area();          // toda Shape debe proporcionar un 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 debe definir area y perimeter. Una vez que lo hace, un Circle es una Shape y puede almacenarse en una variable de tipo Shape.

Muchas clases, un solo tipo

La potencia se aprecia cuando varias clases sin relación entre sí implementan la misma interfaz. El código escrito contra Shape las maneja todas:

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, sea cual sea su clase
        }
        System.out.printf("total area: %.2f%n", total);
    }
}

El bucle nunca pregunta "¿esto es un Circle o un Rectangle?" - simplemente llama a area() y confía en el contrato. Añadir un Triangle más adelante no requiere ningún cambio aquí.

Implementar múltiples interfaces

Una clase extiende solo una clase, pero puede implementar cualquier número de interfaces; así es como Java logra de forma segura la "herencia múltiple" de comportamiento:

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();
    }
}

Enumera las interfaces separadas por comas después de implements. La clase debe satisfacerlas todas.

Métodos default y static

Desde Java 8, una interfaz puede incluir cuerpos de método. Un método default da a las clases que la implementan una implementación lista para usar que heredan gratis (y pueden sobrescribir):

interface Greeter {
    String name();

    default String greet() {        // implementación compartida
        return "Hello, " + name();
    }
}

class English implements Greeter {
    public String name() { return "world"; }
    // greet() se hereda de la interfaz
}

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

Los métodos default permiten que una interfaz evolucione: añadir un método sin romper a todos los implementadores existentes. Un método de interfaz static, en cambio, es una utilidad que invocas sobre la propia interfaz, como Comparator.naturalOrder().

Constantes

Los campos de una interfaz son implícitamente public static final: son constantes, no estado de instancia:

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

Las interfaces tradicionalmente no guardan estado por objeto; la ausencia de campos de instancia es parte de lo que las distingue de las clases.

Interfaces funcionales

Una interfaz con exactamente un método abstracto es una interfaz funcional, y puedes implementarla con una expresión lambda en lugar de toda una clase:

interface Transformer {
    int apply(int x);
}

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

Esta es la base de los lambdas de Java y de los tipos de java.util.function (Function, Predicate, Supplier y compañía). La anotación @FunctionalInterface hace explícita la intención y permite que el compilador imponga la regla de un solo método.

Interfaz frente a clase abstracta

Ambas te permiten programar contra una abstracción, así que ¿cuándo eliges cada una?

• Interfaz - una capacidad que clases sin relación entre sí pueden compartir. Un Bird y un Airplane pueden ser ambos Flyable. Una clase puede implementar muchas. Sin estado de instancia.
• Clase abstracta - estado y código compartidos entre clases estrechamente relacionadas. Un Cat y un Dog ambos extienden Animal, heredando campos comunes y métodos parcialmente implementados. Una clase extiende solo una.

Un patrón habitual las combina: una interfaz define el contrato y una clase abstracta implementa las partes repetitivas, de modo que las subclases concretas solo rellenan los detalles específicos.

Siguiente: clases abstractas

Las interfaces definen comportamiento sin estado. Las clases abstractas se sitúan a medio camino entre las interfaces y las clases completas: pueden declarar métodos sin implementar y además llevar campos y constructores. Ese es el tema de la siguiente página.