告诉编译器一个 <Object> 等价于它想要的 <?>

Question

我有一些对象可以预先生成一些配置，以便它们以后可以更快地处理计算（可能是几次）。我正在尝试对其进行通用化以避免将配置作为Object 传递并每次都进行转换。

interface IComputable<T> {
    T configure(); // Generate configuration object
    int compute(T conf); // Run the computation based on the pre-generated configuration
    float precision(T conf); // Make the compute() computation finer-grained
    ...
}

class ComputableInfo {
    IComputable<?> computable;
    Object config; // Real type is <?>
    int result;

    ComputableInfo(String id) {
        computable = ComputableFactory.createFrom(id);
        config = computable.configure();
        result = computable.compute(config); // <<<--- The method compute(capture#3-of ?) in the type TestInterface.IComputable<capture#3-of ?> is not applicable for the arguments (Object)
    }
}

我收到编译错误：

TestInterface.IComputable 类型中的方法 compute(capture#3-of ?) 不适用于参数 (Object)

当然，我可以将int compute(T conf) 替换为int compute(Object conf)，但我必须将其显式转换为适当的T。这不是什么大问题，但它使代码不那么明显。

我也可以将ComputableInfo 设为通用

interface ComputableInfo<T> {
    IComputable<T> computable;
    T config;
    ...

但这会在其他一些地方产生编译问题（主要是“原始类型”警告），我想避免比以前的解决方法更多的地方（使用Object而不是T）。

有没有办法做到这一点？我什至愿意在编译器设置中将此类问题从错误变为警告，或者可能有一个额外的私有方法可以在单个对象中返回 config 和 result？

编辑：如果我将ComputableInfo 设为通用，则添加“进一步的编译问题”：我在接口中有另一个方法（参见已编辑），它通过ComputableInfo 调用：

ComputableInfo<?> info = getInfo(id);
info.computable.precision(info.config); // <<<--- (same kind of error)

问题是ComputableInfo 无法知道Computable<T> 的T 类型（或者我不知道），因为它来自一个从配置文件构建它的工厂。

Answer 1

从通配符类型中获取对象并将其传递回同一对象，这是泛型类型系统的一个已知限制。例如，当你有

List<?> list = …

您可能希望将一个元素从一个索引复制到另一个索引

Object o = list.get(0);
list.set(1, o);

但它不起作用，即使你避免使用不可表示类型的局部变量。换句话说，即使以下内容也无法编译：

list.set(1, list.get(0));

但是您可以添加一个通用的辅助方法来执行该操作，方法是允许在操作期间捕获类型参数中的通配符类型：

static <T> void copyFromTo(List<T> l, int from, int to) {
    l.set(to, l.get(from));
}

List<?> list = …
copyFromTo(list, 0, 1); // now works

---

您也可以将此模式应用于您的案例：

class ComputableInfo {
    IComputable<?> computable;
    Object config; // Real type is <?>
    int result;

    ComputableInfo(String id) {
        computable = ComputableFactory.createFrom(id);
        configureAndCompute(computable);
    }

    private <T> void configureAndCompute(IComputable<T> computable) {
        T typedConfig = computable.configure();
        this.config = typedConfig;
        this.result = computable.compute(typedConfig);
    }
}

这有效，不需要将ComputableInfo 设为通用。

如果您需要捕获类型的时间超过单个方法，例如如果要多次使用创建的config，可以使用封装：

class ComputableInfo {
    static final class CompState<T> {
        IComputable<T> computable;
        T config;

        CompState(IComputable<T> c) {
            computable = c;
        }
        private void configure() {
            config = computable.configure();
        }
        private int compute() {
            return computable.compute(config);
        }
    }
    CompState<?> state;
    int result;

    ComputableInfo(String id) {
        state = new CompState<>(ComputableFactory.createFrom(id));
        state.configure();
        result = state.compute();
    }
}

这样，您仍然可以避免将类型参数导出给ComputableInfo 的用户。

Answer 2

您需要使用下限通配符。 Object 本身不符合通配符 ?。

class ComputableInfo {
    IComputable<? super Object> computable;
    Object config;
    int result;

    ComputableInfo(String id) {
         computable = null;
         config = computable.configure();
         result = computable.compute(config);
    }
}

---

一个下限表明IComputable 将是Object 的一个实例或某个对象的一个​​实例是Object 的超类（实际上该对象是所有Objects 的父类）。为了更好的理解，让我们使用而不是Number：

IComputable<Integer> computableInteger = ...;
IComputable<Number> computableNumber = ...;
IComputable<Object> computableObject = ...;

IComputable<? super Number> computableSuperNumber = ...;
computableSuperNumber = computableInteger;                  // doesn't compile
computableSuperNumber = computableNumber;                   // ok
computableSuperNumber = computableObject;                   // ok

---

但是，将Integer 或Double 传递给该实例的方法是安全的。在computableSuperObject 下面的sn-p 中引用了一个IComputable，它可能是以下之一：

• IComputable<Number>
• IComputable<Object>。

因为引用可能是IComputable<Number>，只要Object 可以是ex，只要不适合Object 计算就是非法的。 String.

IComputable<? super Number> computableSuperNumber = ...;

Integer integer = 1;
Double d = 1d;
Number number = 1;
Object object = 1;                     // the Object can be also "string", see below
Object objectString = "string";
String string = "string";

computableSuperNumber.compute(integer);                     // ok
computableSuperNumber.compute(d);                           // ok
computableSuperNumber.compute(number);                      // ok
computableSuperNumber.compute(object);                      // doesn't compile
computableSuperNumber.compute(objectString);                // doesn't compile
computableSuperNumber.compute(string);                      // doesn't compile