根据this article，您可以使用以下命令访问接口A中的默认方法

A.super.foo();

这可以如下使用（假设接口A和C都有默认方法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和C都可以有.foo()方法，并且可以选择特定的默认实现，或者可以使用一个（或两个）作为新foo()方法的一部分。您也可以使用相同的语法来访问实现类中其他方法的默认版本。
方法调用语法的正式描述可以在JLS的第15章中找到。

这个答案主要是为来自问题45047550的用户编写的，该问题已关闭。
Java 8接口引入了多重继承的一些方面。默认方法有一个实现的函数体。要从超类调用方法，可以使用关键字super，但如果你想用超接口来实现，则需要显式命名它。

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

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

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

public class Example extends ParentClass implements InterfaceFoo, InterfaceBar {
    public void hello() {
        super.hello(); // (note: ParentClass.super could not be used)
        InterfaceFoo.super.hello();
        InterfaceBar.super.hello();
    }
    
    public static void main(String[] args) {
        new Example().hello();
    }
}

输出：

你好家长班！
你好InterfaceFoo！
你好InterfaceBar！

下面的代码应该可以工作。

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

输出：

B.foo
A.foo

你不需要覆盖接口的默认方法。只要像下面这样调用它：

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

输出：

A.foo

这取决于你的选择是否要覆盖接口的默认方法。因为默认方法类似于类的示例方法，可以直接在实现类对象上调用。（简而言之，接口的默认方法由实现类继承）

考虑以下示例：

interface I{
    default void print(){
    System.out.println("Interface");
    }
}

abstract class Abs{
    public void print(){
        System.out.println("Abstract");
    }

}

public class Test extends Abs implements I{

    public static void main(String[] args) throws ExecutionException, InterruptedException 
    {

        Test t = new Test();
        t.print();// calls Abstract's print method and How to call interface's defaut method?
     }
}

调用Java8函数接口的默认方法

@Functional Interface
interface Process {
   String preInit();
   default String postInit() {
       return "PostInit";
   }
}

public class ProcessImpl {
  Process process = () -> ("PreInit");
  String preInit = process.preInit();
  String postInit = process.postInit(); // Calling default method "postInit()" from functional interface
  System.out.println(preInit);
  System.out.println(postInit);
}

Output:
PreInit
PostInit