fondo - Llamar explícitamente a un método predeterminado en Java

colorear un jlabel java

Question

Java 8 introduce métodos predeterminados para proporcionar la capacidad de ampliar interfaces sin la necesidad de modificar las implementaciones existentes.

Me pregunto si es posible invocar explícitamente la implementación predeterminada de un método cuando ese método ha sido anulado o no está disponible debido a implementaciones predeterminadas conflictivas en diferentes interfaces.

interface A {
    default void foo() {
        System.out.println("A.foo");
    }
}

class B implements A {
    @Override
    public void foo() {
        System.out.println("B.foo");
    }
    public void afoo() {
        // how to invoke A.foo() here?
    }
}

Considerando el código anterior, ¿cómo llamarías a A.foo() desde un método de clase B?

Answer 1

El siguiente código debería funcionar.

public class B implements A {
    @Override
    public void foo() {
        System.out.println("B.foo");
    }

    void aFoo() {
        A.super.foo();
    }

    public static void main(String[] args) {
        B b = new B();
        b.foo();
        b.aFoo();
    }
}

interface A {
    default void foo() {
        System.out.println("A.foo");
    }
}

Salida:

B.foo
A.foo

Answer 2

No es necesario que anule el método predeterminado de una interfaz. Simplemente llámalo así:

public class B implements A {

    @Override
    public void foo() {
        System.out.println("B.foo");
    }

    public void afoo() {
        A.super.foo();
    }

    public static void main(String[] args) {
       B b=new B();
       b.afoo();
    }
}

Salida:

A.foo

Answer 3

Según este artículo accedes al método predeterminado en la interfaz A usando

A.super.foo();

Esto podría usarse de la siguiente manera (suponiendo que las interfaces A y C tengan los métodos predeterminados foo() )

public class ChildClass implements A, C {
    @Override    
    public void foo() {
       //you could completely override the default implementations
       doSomethingElse();
       //or manage conflicts between the same method foo() in both A and C
       A.super.foo();
    }
    public void bah() {
       A.super.foo(); //original foo() from A accessed
       C.super.foo(); //original foo() from C accessed
    }
}

A y C pueden tener métodos .foo() y se puede elegir la implementación predeterminada específica o puede usar uno (o ambos) como parte de su nuevo método foo() . También puede usar la misma sintaxis para acceder a las versiones predeterminadas en otros métodos en su clase de implementación.

La descripción formal de la sintaxis de invocación del método se puede encontrar en el capítulo 15 de JLS .