如何在 Java 8 编译时确保方法签名“实现”功能接口

Question

在 Java 8 中是否有任何类似 implements 关键字的方法？

假设我有一个功能接口：

@FunctionalInterface
interface LongHasher {
    int hash(long x);
}

还有一个包含 3 个静态方法的库“实现”这个功能接口：

class LongHashes {
    static int xorHash(long x) {
        return (int)(x ^ (x >>> 32));
    }
    static int continuingHash(long x) {
        return (int)(x + (x >>> 32));
    }
    static int randomHash(long x) {
         return xorHash(x * 0x5DEECE66DL + 0xBL);
    }
}

将来我希望能够互换地使用对这 3 种方法的任何引用作为参数。例如：

static LongHashMap createHashMap(LongHasher hasher) { ... }
...
public static void main(String[] args) {
    LongHashMap map = createHashMap(LongHashes::randomHash);
    ...
}

如何在编译时确保LongHashes::xorHash、LongHashes::continuingHash 和LongHashes::randomHash 与LongHasher.hash(long x) 具有相同的签名？

Answer 1

过去我也希望这样做，但不，你不能那样做。但你知道。在 Java 8 之前就有 Java。改为这样做：

enum LongHashes implements LongHasher {
    XOR {
        @Override
        public int hash(long x) { ... }
    },
    CONTINUING {
        @Override
        public int hash(long x) { ... }
    },
    RANDOM {
        @Override
        public int hash(long x) { ... }
    }
}

然后：

public static void main(String[] args) {
    LongHashMap map = createHashMap(LongHashes.RANDOM);
    ...
}

Answer 2

没有您要求的这种语法结构。但是，您可以创建一个静态常量，在其中显式地将方法引用分配给您的接口：

class LongHashes {
    private static final LongHasher XOR_HASH = LongHashes::xorHash;
    private static final LongHasher CONTINUING_HASH = LongHashes::continuingHash;
    private static final LongHasher RANDOM_HASH = LongHashes::randomHash;

    static int xorHash(long x) {
        return (int)(x ^ (x >>> 32));
    }
    static int continuingHash(long x) {
        return (int)(x + (x >>> 32));
    }
    static int randomHash(long x) {
         return xorHash(x * 0x5DEECE66DL + 0xBL);
    }
}

这样，如果方法签名或接口以不兼容的方式更改，您的编译将中断。如果你愿意，你可以声明它们public 并使用而不是方法引用。

如果您担心这些静态 lambda 在运行时会挂在内存中，您可以将此声明移动到单独的类（例如，嵌套），该类可以编译但从不加载。

Answer 3

您可以声明函数对象，而不是方法。

class LongHashes {

    static final LongHasher xorHash = x -> {
        return (int)(x ^ (x >>> 32));
    };

    ... etc


    LongHashMap map = createHashMap(LongHashes.randomHash);

Answer 4

一种方法是直接从LongHashes 类返回LongHasher：

class LongHashes {
  private static int xorHashImpl(long x) {
    return (int)(x ^ (x >>> 32));
  }
  static LongHasher xorHash() {
    return LongHashes::xorHashImpl;
  }
}

但这会在您的 LongHashes 类中添加一些代码并将其绑定到 LongHasher 接口，这可能是不可取的（尽管这基本上是您所要求的）。

Answer 5

或者只创建 3 个实现 LongHasher 的类。当你需要一个 LongHasher 时，获取或创建一个实例并传递它：

LongHasher longHasher = ... // new RandomLongHasher(), factory, .......
LongHashMap map = createHashMap(longHasher);

在这里将函数编写为静态方法：

• 让人难以理解
• 听起来像是在重新发明轮子；轮子是接口/类，通过在问题描述中的引号之间使用“接口”来暗示重新发明；-)

我们不必在任何地方都使用 lambda。

Answer 6

虽然我发现 Tagir 的答案是一个不错的 hack，但在创建新哈希器时很容易忘记添加私有常量。

像往常一样，在处理潜在的重构问题时，我认为测试就是答案：

public class LongHashesTest {

    @Test
    public void xorHash() {
        LongHasher xorHash = LongHashes::xorHash;

        assertEquals(1768181579, xorHash.hash(34312465426524234l));
    }

    @Test
    public void continuingHash() {
        LongHasher continuingHash = LongHashes::continuingHash;

        assertEquals(1529080340, continuingHash.hash(74543524355l));
    }

    @Test
    public void randomHash() {
        LongHasher randomHash = LongHashes::randomHash;

        assertEquals(-1100764221, randomHash.hash(4343245345432154353l));
    }
}