您可以从子类接口的接口调用父接口的默认方法吗？

Question

在Java 8中，我有类似以下内容：

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

有没有一种方法可以从ImplementsB调用默认的功能接口行为，而不必创建匿名内部类并调用该内部类？

这会有副作用（两次调用ImplementsA的方法），需要调用父级的实现，然后让子级的实现能够调用子级的默认实现，并在需要时进行一些专门化。如您所见，调用父级的实现非常简单，但是我看不到一种避免重写默认实现的方法，除非我在实现子接口的类上添加了间接层，并且没有办法实现。

例如，如果A解锁或提供了对资源的访问权（例如数据库），而B解锁了第二个资源（另一个数据库），则我看不到任何方法使代码解锁A，然后B通过使用功能接口来强制执行此合同。
A和B被称为。 您可以执行一个深层次的操作，但是看起来不可能达到N级。

我打算使用lambda来避免进行昂贵的调用，而是对我的库用户强制执行操作的语义顺序。

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

Answer 1

您可以使用调用继承的interface default方法InterfaceName.super。这些规则与其他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。