您能从子类该接口的接口调用父接口的默认方法吗？[副本]

Question

在Java8中,我有如下内容：

package test;
public class SimpleFuncInterfaceTest {
    public static void carryOutWork(AFunctionalInterface sfi){
        sfi.doWork();
    }
    public static void main(String[] args) {
        carryOutWork(() -> System.out.println("Do work in lambda exp impl..."));
        AImplementor implementsA = new AImplementor();
        //carryOutWork(() -> implementsA.doWork());
        BImplementor implementsB = new BImplementor();
        carryOutWork(() -> implementsB.doWork());
    }
}

@FunctionalInterface
interface AFunctionalInterface {
    public void doWork();
    default public void doSomeWork(){
        System.out.println("FOO");
    }
}

@FunctionalInterface
interface BFunctionalInterface extends AFunctionalInterface {
    @Override
    default public void doSomeWork(){
        System.out.println("BAR");//Unreachable in same object?
    }
}

class AImplementor implements AFunctionalInterface {
    @Override
    public void doWork() {
        doSomeWork();
    }
}

class BImplementor extends AImplementor implements BFunctionalInterface {
    public void doSomeWork(){
        super.doSomeWork();
        new BFunctionalInterface(){
            @Override
            public void doWork() {
            }}.doSomeWork();
            System.out.println("WUK WUK");
    }
    @Override
    public void doWork() {
        doSomeWork();
    }
}

例如，如果A解锁或提供了对一个资源（比如数据库）的访问，而B解锁了第二个资源（另一个数据库），我认为没有办法使代码解锁A，然后B通过使用函数接口强制执行这个契约，要求调用A和B。一层深的你可以做到，但N层深的看起来就不可能了。

我打算使用lambdas来避免进行昂贵的调用，但要对我的库的用户执行语义操作顺序。

这个问题与“在Java中显式调用默认方法”并不完全相同，因为这个问题涉及的是深度N级的接口，而不仅仅是调用父接口默认方法。

Answer 1

可以使用InterfaceName.super调用继承的InterfaceDefault方法。规则与其他super方法调用相同：您可以调用已覆盖的继承方法，但不能直接调用继承方法可能已覆盖的方法。例如。

interface A
{
    void foo();
    default void toOverride() {
        System.out.println("A");
    }
}
interface B extends A
{
    default void toOverride() {
        A.super.toOverride();
        System.out.println("B");
    }
}
interface C extends B
{
    default void toOverride() {
        A.super.toOverride();// does not work
        B.super.toOverride();
        System.out.println("B");
    }
}
class D implements B
{
    public void toOverride() {

    }    
    public void foo() {
        D.this.toOverride();
        B.super.toOverride();
        A.super.toOverride(); // does not work!
    }
}

但是如果每个重写方法都调用它的超级方法，那么就会有一个调用链。但是，请记住，我们谈论的是接口。实现始终可以重写默认方法，而根本不需要调用super。