Explizites Aufrufen einer Standardmethode in Java

In Java 8 werden Standardmethoden eingeführt , mit denen Schnittstellen erweitert werden können, ohne dass vorhandene Implementierungen geändert werden müssen.

Ich frage mich, ob es möglich ist, die Standardimplementierung einer Methode explizit aufzurufen, wenn diese Methode überschrieben wurde oder aufgrund widersprüchlicher Standardimplementierungen in verschiedenen Schnittstellen nicht verfügbar ist.

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?
    }
}

Wie würden Sie unter Berücksichtigung des obigen Codes A.foo()eine Methode der Klasse B aufrufen ?

Gemäß diesem Artikel gelangen Sie Standardmethode in der Schnittstelle Amit

A.super.foo();

Dies kann wie folgt verwendet werden (vorausgesetzt, Schnittstellen Aund Cbeide haben Standardmethoden 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
    }
}

Aund Ckönnen beide .foo()Methoden haben und die spezifische Standardimplementierung kann ausgewählt werden oder Sie können eine (oder beide) als Teil Ihrer neuen foo()Methode verwenden. Sie können dieselbe Syntax auch verwenden, um auf die Standardversionen in anderen Methoden Ihrer Implementierungsklasse zuzugreifen.

Eine formale Beschreibung der Syntax des Methodenaufrufs finden Sie in Kapitel 15 des JLS .

Der folgende Code sollte funktionieren.

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

Ausgabe:

B.foo
A.foo

Diese Antwort richtet sich hauptsächlich an Benutzer, die aus der geschlossenen Frage 45047550 kommen .

Java 8-Schnittstellen führen einige Aspekte der Mehrfachvererbung ein. Standardmethoden haben einen implementierten Funktionskörper. Um eine Methode aus der Superklasse aufzurufen, können Sie das Schlüsselwort verwenden super. Wenn Sie dies jedoch mit einer Superschnittstelle erstellen möchten, müssen Sie diese explizit benennen.

class ParentClass {
    public void hello() {
        System.out.println("Hello ParentClass!");
    }
}

interface InterfaceFoo {
    default public void hello() {
        System.out.println("Hello InterfaceFoo!");
    }
}

interface InterfaceBar {
    default public void hello() {
        System.out.println("Hello InterfaceBar!");
    }
}

public class Example extends ParentClass implements InterfaceFoo, InterfaceBar {
    public void hello() {
        super.hello(); // (note: ParentClass.super is wrong!)
        InterfaceFoo.super.hello();
        InterfaceBar.super.hello();
    }

    public static void main(String[] args) {
        new Example().hello();
    }
}

Ausgabe:

Hallo ParentClass!
Hallo InterfaceFoo!
Hallo InterfaceBar!

Sie müssen die Standardmethode einer Schnittstelle nicht überschreiben. Nennen Sie es einfach wie folgt:

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

Ausgabe:

A.foo