静态成员中的通用参数声明

为什么不允许定义这样的静态成员：

private static final <T extends Object> Map<Class<T>, BiFunction<T, T, Boolean>> SPECIFIC_HANDLERS = new HashMap<>();

相反，只允许在未指定的情况下使用它：

private static final Map<Class<?>, BiFunction<?, ?, Boolean>> SPECIFIC_HANDLERS = new HashMap<>();

是否有解决方法，以便我可以定义 BiFunction 的两个参数必须具有相同类型，并且 Map 的键必须是这些参数的类类型？

更新以澄清（因为@Mena的建议不适合我）：

我想要一个用于通用 equals 帮助器的数组 equals 方法的映射。通用助手正式接收两个对象。如果它们是数组，我必须将其传递给重载的 Arrays.equals() 方法之一。我想查找正确的方法（示例 1）：

private static final Map<Class<?>, BiFunction<?, ?, Boolean>> ARRAY_EQUALS_HANDLER = new HashMap<>();

static
{
    ARRAY_EQUALS_HANDLER.put( Object[].class,  (l, r) -> Arrays.equals( (Object[])  l, (Object[])  r ));
    ARRAY_EQUALS_HANDLER.put( boolean[].class, (l, r) -> Arrays.equals( (boolean[]) l, (boolean[]) r ));
    ....
}

然后像这样使用它：

boolean equal = ARRAY_EQUALS_HANDLER.get( anObj1.getClass()).apply(anObj1, anObj2);

该构造（根据 Mena 的说法）甚至无法编译：

private static <T extends Object> Map<Class<T>, BiFunction<T, T, Boolean>> getSpecificHandlers() 
{
    Map<Class<T>, BiFunction<T, T, Boolean>> result = new HashMap<>();
    result.put( Object[].class,  (l, r) -> Arrays.equals( (Object[])  l, (Object[])  r ));
    result.put( boolean[].class, (l, r) -> Arrays.equals( (boolean[]) l, (boolean[]) r ));
    return result;
}

如果我在方法外部填充生成的地图：

 @SuppressWarnings( { "unchecked", "rawtypes" })
private static final Map<Class<?>, BiFunction<?, ?, Boolean>> ARRAY_EQUALS_HANDLER = (Map) getSpecificHandlers();

static
{
    ARRAY_EQUALS_HANDLER.put( Object[].class,  (l, r) -> Arrays.equals( (Object[])  l, (Object[])  r ));
    ...
}

那么整个类型安全性就消失了，因为在将其分配给最终静态成员时我必须进行（未经检查的）类型转换。

我上面的示例 1 有效，但是在使用它时我必须转换收到的 lambda：

private static <T extends Object> boolean equalsArray( T anArray, T anOtherArray) {
    Object o = ARRAY_EQUALS_HANDLER.get( anArray.getClass());
    @SuppressWarnings( "unchecked")
    BiFunction<T, T, Boolean> func = (BiFunction<T, T, Boolean>) o;

    Boolean result = func.apply( anArray, anOtherArray);
    return result;
}

您正在使用泛型方法习惯用法（返回类型之前的类型参数声明）作为常量声明。

该习惯用法无法编译。

正如其他地方提到的，您不能在静态上下文中使用类泛型类型。

你什么can解决方法是声明一个静态方法而不是常量 - 如下所示：

private static final <T extends WhateverBound> Map<Class<T>, 
    BiFunction<T, T, Boolean>> 
    getSpecificHandlers(T t) {

    // return new HashMap<Class<T>, BiFunction<T, T, Boolean>>();
    // much easier on the eye - thanks Andy Turner
    return new HashMap<>();
}

假设：

static class WhateverBound{}
static class Foo extends WhateverBound {}

然后您可以调用您的方法：

Map<Class<Foo>, BiFunction<Foo, Foo, Boolean>> map = 
getSpecificHandlers(new Foo());

当然请注意，final此处的关键字具有非常不同的含义，并且可能可以完全省略。

Or...

您可以将其保留为常量，并在所有类型参数化中重复通配符/边界模式。

例如：

private static final Map<Class<? extends WhateverBound>, 
     BiFunction<? extends WhateverBound, ? extends WhateverBound, Boolean>> 
       SPECIFIC_HANDLERS = new HashMap<>();

static {
    SPECIFIC_HANDLERS.put(Foo.class, (f, ff) -> true);
}