Métodos static en interfaces

1. Introducción

Hasta Java 8, una interfaz era exclusivamente «contrato»: solo métodos abstractos, ninguna implementación, ninguna lógica, solo promesas. Pero a partir de Java 8, las interfaces se volvieron un poco más «autónomas»: ahora pueden contener no solo métodos default, sino también métodos static.

Los métodos static en interfaces son métodos que pertenecen a la propia interfaz, y no a sus implementaciones (clases). No requieren crear un objeto y se invocan directamente mediante el nombre de la interfaz.

Analogía:
Los métodos static en interfaces son como un manual o recordatorio pegado en la pared de la oficina: cada empleado (clase) puede usarlo, pero el recordatorio no pertenece a ningún empleado en particular.

Los métodos static en interfaces permiten agrupar funciones auxiliares relacionadas con esa interfaz, sin ensuciar el espacio de nombres de las clases que la implementan.

Sintaxis de los métodos static en interfaces

Los métodos static se declaran dentro de la interfaz con la palabra clave static. Pueden contener una implementación (código entre llaves) y solo pueden invocarse mediante el nombre de la interfaz.

Ejemplo:

public interface MathUtils {
    static int sum(int a, int b) {
        return a + b;
    }

    static double average(int a, int b) {
        return (a + b) / 2.0;
    }
}

Invocación de un método static de la interfaz:

int result = MathUtils.sum(5, 7);        // 12
double avg = MathUtils.average(10, 20);  // 15.0

Atención:
¡No puedes invocar un método static de la interfaz a través de una clase que la implemente ni de un objeto! Solo mediante el nombre de la interfaz.

2. ¿En qué se diferencian los métodos static de la interfaz de los métodos default?

Static-métodos:

• Pertenecen a la propia interfaz.
• No son heredados por las clases que implementan la interfaz.
• No pueden invocarse mediante un objeto de la clase.
• No pueden sobrescribirse en la clase que implementa la interfaz.
• Solo pueden invocarse mediante el nombre de la interfaz.

default-métodos:

• Pertenecen al objeto (instancia) de la clase que implementa la interfaz.
• Pueden sobrescribirse en la clase que implementa la interfaz.
• Pueden invocarse mediante un objeto de la clase que implementa la interfaz.
• Son heredados por las clases que implementan la interfaz.

En resumen: los default-métodos amplían las capacidades del objeto, mientras que los static-métodos — de la propia interfaz.

Ejemplo comparativo:

interface Printer {
    default void print(String text) {
        System.out.println("Default: " + text);
    }

    static void info() {
        System.out.println("Printer interface v1.0");
    }
}

class ConsolePrinter implements Printer {}

public class Main {
    public static void main(String[] args) {
        Printer.info(); // Llamada al método static a través de la interfaz

        ConsolePrinter cp = new ConsolePrinter();
        cp.print("Hello!"); // Llamada al método default a través del objeto
        // cp.info(); // ¡Error! No se puede invocar un método static a través de un objeto
    }
}

3. ¿Para qué sirven los métodos static en interfaces?

Antes de que existieran los métodos static en interfaces, si necesitabas añadir una función utilitaria relacionada con la interfaz, tenías que crear clases separadas con el sufijo Utils o Helper:

public interface Movable {
    void move(int x, int y);
}

public class MovableUtils {
    public static void resetPosition(Movable m) {
        m.move(0, 0);
    }
}

Ahora se puede hacer directamente en la interfaz:

public interface Movable {
    void move(int x, int y);

    static void resetPosition(Movable m) {
        m.move(0, 0);
    }
}

Esto hace que el código sea más lógico y cohesionado: los métodos relacionados con la interfaz ahora viven dentro de ella.

Ventajas:

• Agrupación de funciones utilitarias junto al contrato de la interfaz.
• No «ensucian» el espacio de nombres de las clases que implementan.
• Mejoran la legibilidad y el mantenimiento del código.

4. Restricciones y particularidades de los métodos static de la interfaz

Los métodos static de la interfaz no se heredan por las clases que la implementan.

No pueden invocarse mediante un objeto de una clase que implementa la interfaz ni mediante el nombre de esa clase. ¡Solo mediante el nombre de la interfaz!

Los métodos static en una interfaz siempre contienen implementación: no pueden ser abstract ni default.

Siempre contienen implementación.

Los métodos static no pueden acceder a métodos o variables no estáticos de la interfaz.

Solo pueden acceder a otros miembros static de la interfaz (por ejemplo, a constantes static final).

Los métodos static de una interfaz pueden ser privados (Java 9+).

Se pueden crear métodos auxiliares private static para su uso dentro de la interfaz.

5. Ejemplo: métodos static para la interfaz Movable

Veamos cómo añadir métodos static a la interfaz Movable. Supongamos que tenemos la interfaz Movable, que implementan distintas clases (por ejemplo, robots, animales, vehículos).

Paso 1. Declarar la interfaz con un método static:

public interface Movable {
    void move(int x, int y);

    static void resetPosition(Movable obj) {
        obj.move(0, 0);
    }

    static double distance(int x1, int y1, int x2, int y2) {
        int dx = x2 - x1;
        int dy = y2 - y1;
        return Math.sqrt(dx * dx + dy * dy);
    }
}

Paso 2. Implementar la interfaz en una clase:

public class Robot implements Movable {
    private int x, y;

    public Robot(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public void move(int x, int y) {
        System.out.println("El robot se mueve al punto (" + x + "," + y + ")");
        this.x = x;
        this.y = y;
    }

    public void printPosition() {
        System.out.println("Posición actual: (" + x + "," + y + ")");
    }
}

Paso 3. Usar los métodos static de la interfaz:

public class Main {
    public static void main(String[] args) {
        Robot robby = new Robot(10, 15);
        robby.printPosition();

        // Restablecer la posición mediante un método static de la interfaz
        Movable.resetPosition(robby);
        robby.printPosition();

        // Calcular la distancia entre puntos mediante un método static de la interfaz
        double dist = Movable.distance(0, 0, 10, 15);
        System.out.println("Distancia: " + dist);
    }
}

Resultado:

Posición actual: (10,15)
El robot se mueve al punto (0,0)
Posición actual: (0,0)
Distancia: 18.027756377319946

Ten en cuenta:
Invocamos Movable.resetPosition(robby), y no robby.resetPosition(). Los métodos static son prácticos para operaciones que lógicamente pertenecen a la interfaz, pero no a un objeto concreto.

6. Métodos private static en interfaces

A veces, en una interfaz se necesitan métodos auxiliares solo para uso interno (por ejemplo, para no duplicar código en varios métodos static o default). Desde Java 9, las interfaces admiten métodos private static.

Ejemplo:

public interface Logger {
    static void logInfo(String message) {
        log("INFO", message);
    }
    static void logError(String message) {
        log("ERROR", message);
    }
    private static void log(String level, String message) {
        System.out.println("[" + level + "] " + message);
    }
}

Ahora log() no está disponible desde fuera de la interfaz, pero se utiliza dentro de otros métodos static.

7. ¿Dónde hay métodos static en la biblioteca estándar de Java?

Los métodos static en interfaces se usan activamente en la biblioteca estándar de Java, especialmente en las colecciones y en las interfaces funcionales.

Ejemplos:

• Comparator.comparing(), Comparator.reverseOrder() — métodos static de la interfaz Comparator.
• Predicate.isEqual() — método static de la interfaz Predicate.
• List.of(), Set.of(), Map.of() (Java 9+) — métodos static para crear colecciones inmutables.

Ejemplo con Comparator:

import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        Comparator<String> cmp = Comparator.reverseOrder();
        int res = cmp.compare("a", "b"); // número positivo, porque "a" > "b" en orden inverso
        System.out.println(res);
    }
}

8. Errores típicos al trabajar con métodos static de la interfaz

Error nº 1: intentar invocar un método static mediante un objeto de la clase que implementa.
¡Esto no funcionará! Un método static de la interfaz se invoca solo mediante el nombre de la interfaz, por ejemplo, Movable.resetPosition(obj), y no obj.resetPosition().

Error nº 2: intentar sobrescribir un método static de la interfaz en la clase que implementa.
¡Los métodos static no se heredan ni se sobrescriben! Si declaras en la clase un método static con el mismo nombre, será un método completamente distinto, no relacionado con la interfaz.

Error nº 3: olvidar que los métodos static no pueden acceder a miembros no estáticos.
Los métodos static de la interfaz solo pueden usar miembros static (por ejemplo, constantes static final), pero no pueden acceder a métodos o variables no estáticos.

Error nº 4: confusión con los métodos default.
Los default-métodos se invocan mediante el objeto, los static — solo mediante el nombre de la interfaz. ¡No los confundas!