12

在 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 的方法 2 次），需要调用父级的实现，然后让子级的实现能够调用子级的默认实现，以及一些特殊化（如果需要）。如您所见，调用父级的实现非常容易，但是我看不到避免重写默认实现的方法，除非我向实现子接口的类添加一层间接层，并且无法强制执行.

例如，如果 A 解锁或提供对资源的访问权限，例如数据库，而 B 解锁第二个资源（另一个数据库），我认为没有办法让代码解锁 A，然后 B 通过使用功能接口执行此合同，要求A 和 B 被称为。 一层深你可以做到，但 N 层深看起来是不可能的。

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

这个问题与“在 Java 中显式调用默认方法”不太一样，因为这个问题是关于 N 级深度的接口，而不仅仅是调用父接口的默认方法。

4

1 回答 1

26

您可以使用 调用继承的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。

于 2014-06-18T08:15:07.647 回答