java - 在 Java 中是否可以应用部分类型参数？

Question

我知道 Josh Bloch 的 typesafe heterogeneous container :

<T> void container.put(Class<T>, T);
<T> T container.get(Class<T>);

我还读到了 Neal Gafter 的 "Super" typesafe hetereogeneneous container :

<T> void container.put(TypeToken<T>, T);
<T> T container.get(TypeToken<T>);

---

但是，我无法使用以下类型的容器:

<T> void container.put(Foo<T>, Bar<T>);
<T> Bar<T> container.put(Foo<T>);

其中 Foo 和 Bar 以及任何通用引用类型。

尝试将其写出来，您必须执行以下操作:

// Setting T at the class level would force some fixed
// T or at best a bounded range of types
class Container<A, B/*, T */> {

    // So we can't have this:
    // Map<A<T>, B<T>> map = new HashMap<>();

    // And must do this (at the expense of type safety):
    Map<A<?>, B<?>> map = new HashMap<>();


    <T> void container.put(A<T> a, B<T> b) {
        map.put(a, b);
    } 

    <T> B<T> container.get(A<T> a) {
        // Not sure what to do here
    }
}

然后您就可以执行以下操作:

// This doesn't compile because T is not specified and thus this is not actual Java:

class FooBarContainer extends Container<Foo, Bar, T> {   
   ...
}  

FooBarContainer container = new FooBarContainer();

// Can do this:
container.put(new Foo<String>(), new Bar<String>());
Bar<String> bar = container.get( /* some Foo<String> */ );

// Cannot do this:
container.put(new Foo<Long>(), new Bar<String>());
Bar<String> bar = container.get( /* some Foo<Long> */ );

可惜，这不是合法的 Java。

我在这里看到的是类级泛型与方法级泛型是正交的。那是问题所在吗？如果是这样，有什么办法可以在 Java 中协调吗？

无论如何，在允许此类容器的类型系统中您需要什么。必要的功能叫什么？如果一定要给它命名，我会称之为部分类型参数应用程序，但我确信这个概念一定以某种我不知道的一般形式存在。

Answer 1

类级泛型和方法级泛型结合在一起，它们不是正交的。

我看到一些选项可以解决我认为您正在尝试做的事情。但首先，你必须明白你不能将一个泛型声明为另一个泛型的协变，所以你不能说:

class Container<A<B>> {}

因为“A”是一个类型参数，所以没有关联的类型信息，包括它本身是否是泛型类型。如果你指定“A”是一个有参数的类型那么就可以做到，比如:

class Container<A extends Foo<B>> {}

因此对于第一种情况，您可以使用如下 API:

interface Container<KeyType, ValueType>
{
   void put(KeyType k, ValueType v);
   ValueType get(KeyType k);
}

这将允许每个键/值类型的具体子类型(实际上只是一个 java.util.Map)，例如:

interface StringContainer extends Container<String, String>
{
   void put(String k, String v);
   String get(String k);
}

interface FooBarContainer<C> extends Container<Foo<C>, Bar<C>>
{
   void put(Foo<C> k, Bar<C> v);
   Bar<C> get(Foo<C> k);
}

其中所有键/值对都具有相同的 KeyType 和 ValueType。

将方法级泛型添加到混合中允许您让 KeyType 和 ValueType 仅与方法调用相关，而不是与方法的所有调用相关:

interface VarContainer
{
   <VariantType> void put(Foo<VariantType> k, Bar<VariantType> v);
   <VariantType> Bar<VariantType> get(Foo<VariantType> k);
}

允许在同一 VarContainer 中使用不同的键/值对:

VarContainer vc = ...
vc.put(new Foo<String>(), new Bar<String>());

vc.put(new Foo<Long>(), new Bar<Long>());

这将使您能够在具体的子类中指定您的协变类型:

interface VarContainer<VariantType> extends Container<Foo<VariantType>, Bar<VariantType>>
{
   void put(Foo<VariantType> k, Bar<VariantType> v);
   Bar<VariantType> get(Foo<VariantType> k);
}

此其他选项仅在您知道容器中有 Foo 和 Bar 时才有效:

interface FooBarVarContainer
{
   <VariantType> void put(Foo<VariantType> k, Bar<VariantType> v);
   Bar<VariantType> get(Foo<VariantType> k);
}

并且容器现在仅限于 Foo/Bar 对，但可以使用相同的变体类型来调用两个参数上的 put 以及参数和返回值之间的 get:

FooBarVarContainer vc = ...
vc.put(new Foo<String>(), new Bar<String>()); // ok
vc.put(new Foo<String>(), new Bar<Long>()); // fails to compile
Bar<Long> = vc.get(new Foo<Long>()); // ok

这是否能帮助您解决问题？

还应该提到的是，将可变实例作为键放入映射中并不是一个好的做法，因为映射键不仅应该正确实现 hashCode 和 equals 方法，而且一旦插入它们，映射就需要根据需要动态重新索引(如果有的话) key 变了。例如，如果 hashCode 值发生变化，将来在 HashMap 中查找该键可能会失败或找到错误的项目。