扩展另一个泛型类的泛型类的泛型类型参数的绑定不匹配错误

Question

我对 java 中的泛型和继承有疑问。

我想从“createManager”方法中实例化一个“ObjectManager”类，该方法可以从给定类型创建实例。这个“ObjectManager”有一些实用方法（例如：“getDescription”）。

此方法允许我从一个类型实例化一个“ObjectManager”，然后获取例如它的描述（此处为哈希）。

如果输入类型可分配给类型“Foo”，我还想为“FooManager”专门化“ObjectManager”，以便我可以覆盖“getDescription”方法。因此，我在“createManager”方法中测试输入的类型，以了解我是创建“ObjectManager”还是“FooManager”。

代码有效，但我不知道对应于“new FooManager(type)”的输出的通用类型。在我看来，对于 Eclipse 快速修复，类型应该是 但这会导致错误：

Bound mismatch：类型 T 不是 FooManager

类型的有界参数 的有效替代品

我的代码：

import java.lang.reflect.InvocationTargetException;
import java.util.Objects;

public class GenericBug {
    private GenericBug() {}
    
    public static void main(String[] args) {
        ObjectManager<Foo> objectManager1 = createManager(Foo.class);
        System.out.println(objectManager1.getDescription());
        
        ObjectManager<Object> objectManager2 = createManager(Object.class);
        System.out.println(objectManager2.getDescription());
    }
    
    private static <T> ObjectManager<T> createManager(Class<T> type) {
        if(Foo.class.isAssignableFrom(type))
            return new FooManager<T>(type);   //Error: Bound mismatch
        return new ObjectManager<T>(type);
    }
}

class ObjectManager<T>{
    public T val;
    public ObjectManager(Class<T> type) {
        try {
            val = type.getConstructor().newInstance();
        } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e) {
            e.printStackTrace();
        }
    }
    
    public String getDescription() {
        return "Hash: " + Objects.hash(val);
    }
}

class FooManager<T extends Foo> extends ObjectManager<T>{

    public FooManager(Class<T> type) {
        super(type);
    }
    
    @Override
    public String getDescription() {
        return super.getDescription() + " value: " + val.getVal();
    }
}

class Foo{
    private double val = Math.random();
    public Foo() {}

    public double getVal() {
        return val;
    }
}

所以我的问题是：为什么会出现这个错误？如何在没有警告的情况下修复它？而且，作为奖励，为什么 Eclipse 提供了一个无法编译的解决方案？这是 Eclipse 错误吗？

提前感谢您的回答。

Answer 1

发生该错误是因为您没有编译时保证 T 是 Foo 的实例。您只有运行时保证 Foo 可以从 T 分配，编译器并不关心。您可以通过抑制它们来真正地使这个编译没有警告：

@SuppressWarnings({ "unchecked", "rawtypes" })
private static <T> ObjectManager<T> createFooManager(Class<T> type) {
    if(Foo.class.isAssignableFrom(type))
        return new FooManager(type);   //Error: Bound mismatch
    return new ObjectManager<T>(type);
}

这可能不是您要寻找的答案，但我认为您无法在不压制警告的情况下摆脱警告。我从这些警告的必然性中推断出最初的方法是不正确的。为什么需要传入一个类作为参数？如果类参数在编译时已知，您可以简单地为不同的类调用不同的方法。如果在编译时该类是未知的，那么您将永远无法从该泛型参数中受益。

Answer 2

问题是您通过isAssignableFrom 混合了泛型的编译时安全性和运行时检查。

我不知道更好的方法：

private static <T> ObjectManager<T> createFooManager(Class<T> type) {
    if (Foo.class.isAssignableFrom(type)) {
        return (ObjectManager<T>) getIt((Class<? extends Foo>) type);
    }
    return new ObjectManager<>(type);

}

private static <R extends Foo> ObjectManager<R> getIt(Class<R> cls) {
    return new FooManager<>(cls);
}

不过，这会引发unchecked warning。

Answer 3

„...为什么会出现这个错误？...“

javac 对您的原始代码报告的错误为您提供了以下原因：

...GenericBug.java:14: error: type argument T#1 is not within bounds of type-variable T#2
            return new FooManager<T>(type);   //Error: Bound mismatch
                                  ^
  where T#1,T#2 are type-variables:
    T#1 extends Object declared in method <T#1>createFooManager(Class<T#1>)
    T#2 extends Foo declared in class FooManager
1 error

T#1 is not within bounds of type-variable T#2 因为：

1. <T> ObjectManager<T> createFooManager(...) 表示您将 T（aka T#1）定义为 no 界限。
2. FooManager<T extends Foo> 的类型参数 T (akaT#2) 使用边界 @987654333 定义@。并且泛型方法的 T 并没有像泛型类所要求的那样扩展 Foo。所以它超出范围。

„...如何解决它...“

您最初的 Foo.class.isAssignableFrom(type) 方法让我觉得不是非常面向对象。所以基本上，I've fixed it this way。

...
private static <T> ObjectManager<T> createObjectManager(Class<T> type) {
        return new ObjectManager<>(type);
} 

private static <S extends Foo> ObjectManager<S> createFooManager(Class<S> type) {
        return new FooManager<>(type);
}
...   

您的 IRL 用例是什么并不明显。所以我不得不做出一些假设。就像我假设您很可能将它与 Foo 的更专业的实现一起使用。所以我介绍了一个 FooJr 来演示解决方案如何处理这个问题：

    ObjectManager<? extends Foo> objectManager1 = createFooManager(Foo.class);
    System.out.println(objectManager1.getDescription());
    
    ObjectManager<?> objectManager2 = createObjectManager(Object.class);
    System.out.println(objectManager2.getDescription());

    objectManager1 = createFooManager(FooJr.class);
    System.out.println(objectManager1.getDescription());        

    objectManager2 = createObjectManager(FooJr.class);
    System.out.println(objectManager2.getDescription());

说一种解决方案比另一种解决方案“更好”或“更差”是主观的；也许是个人品味的问题。但是可以用 objectivity (pun 意图) 说，一种解决方案可以比另一种解决方案更面向对象。有些解决方案肯定比其他解决方案更安全。

“……没有警告？……”

This solution 被证明是更安全的类型。使用 -Xlint:unchecked 运行它。编译器不会报告任何未经检查的警告。这不需要任何@SuppressWarnings(...)。

„...为什么 Eclipse 提供了无法编译的解决方案？...“

Eclipse 只是向您展示了它的最佳猜测，它认为解决问题的方法是什么。 IDE 的本质是给某些东西一个 PASS，javac 或 JLS 绝对不允许。