Chamar explicitamente um método padrão em Java

O Java 8 apresenta métodos padrão para fornecer a capacidade de estender interfaces sem a necessidade de modificar implementações existentes.

Gostaria de saber se é possível invocar explicitamente a implementação padrão de um método quando esse método foi substituído ou não está disponível devido a implementações padrão conflitantes em 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 o código acima, como você chamaria A.foo()de um método da classe B?

Conforme este artigo, você acessa o método padrão na interface Ausando

A.super.foo();

Isso pode ser usado da seguinte maneira (assumindo interfaces Ae Cambos têm métodos padrão 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
    }
}

Ae Cambos podem ter .foo()métodos e a implementação padrão específica pode ser escolhida ou você pode usar um (ou ambos) como parte do seu novo foo()método. Você também pode usar a mesma sintaxe para acessar as versões padrão em outros métodos em sua classe de implementação.

A descrição formal da sintaxe de chamada do método pode ser encontrada no capítulo 15 do JLS .

O código abaixo deve 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");
    }
}

Resultado:

B.foo
A.foo

Esta resposta foi escrita principalmente para usuários provenientes da pergunta 45047550, que está encerrada.

As interfaces Java 8 apresentam alguns aspectos da herança múltipla. Métodos padrão tem um corpo de função implementado. Para chamar um método da superclasse, você pode usar a palavra-chave super, mas se quiser fazer isso com uma super interface, é necessário nomeá-lo explicitamente.

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

Resultado:

Olá ParentClass!
Olá InterfaceFoo!
Olá InterfaceBar!

Você não precisa substituir o método padrão de uma interface. Basta chamá-lo da seguinte maneira:

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

Resultado:

A.foo