Explicitement l'appel d'une méthode par défaut en Java

Question

Java 8 introduit des méthodes par défaut à offrir la possibilité de prolonger les interfaces sans avoir à modifier les applications existantes.

Je me demande si il est possible d'appeler explicitement la valeur par défaut de la mise en œuvre d'une méthode lorsque cette méthode a été remplacée ou n'est pas disponible en raison de conflits implémentations par défaut dans les différentes 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?
    }
}

Considérant le code ci-dessus, comment vous appelez A.foo() à partir d'une méthode de la classe B?

Answer 1

Conformément à cet article, vous accédez à la méthode par défaut dans l'interface A aide

A.super.foo();

Il pourrait être utilisé comme suit (en supposant que les interfaces A et C les deux ont des méthodes par défaut foo())

public class ChildClass implements A, C {
    public void foo(){
       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 et C peut à la fois avoir .foo() méthodes et le défaut de mise en œuvre peut être choisi ou vous pouvez utiliser l'une (ou les deux) dans le cadre de votre nouveau foo() méthode. Vous pouvez également utiliser la même syntaxe pour accéder à la valeur par défaut des versions dans d'autres méthodes dans la mise en œuvre de votre classe.

Answer 2

Ci-dessous le code devrait fonctionner.

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

Sortie:

B.foo
A.foo

Answer 3

Vous n'avez pas besoin de surcharger la méthode par défaut du type d'interface. Appelez simplement comme

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

Sortie: A. foo