Question

假设我有这个初始代码库

public class BaseValue {}

public class ValueHolder<KeyT extends Comparable, ValueT extends BaseValue> {
    public KeyT key;
    public ValueT value;
}

public class ValueProcessor<ValueHolderT extends ValueHolder> {
    public void doSomethingWith(ValueHolderT value) {
    }
}

public class Process {
    public <ValueT extends BaseValue, ValueHolderT extends ValueHolder<?,ValueT>> 
            void run(ValueHolderT value, ValueProcessor<ValueHolderT> processor) {
        processor.doSomethingWith(value);
    }
}

public class Client {
    public static void test() {
        ValueHolder<String,BaseValue> value = null;
        ValueProcessor<ValueHolder<String,BaseValue>> processor = null;

        new Process().run(value, processor);
    }
}

所以...有一种处理方法，在构建时验证值类型的匹配。

在某些时候，当大量代码已经在使用ValueProcessor的这种设计时，我注意到我错过了处理器的任何结果 - 我将通过返回已处理的Key来解决这个问题项目。为了完成这项工作，我将改变这样的代码（现在我返回value.key）：

public class ValueProcessor<KeyT extends Comparable, ValueHolderT extends ValueHolder<KeyT,?>> {
    public KeyT doSomethingWith(ValueHolderT value) {
        return value.key;
    }
}

但是这个更改需要在使用ValueProcessor的所有代码中连续更改（因为添加了新的模板参数）

public class Process {
    public <KeyT extends Comparable, ValueT extends BaseValue, ValueHolderT extends ValueHolder<KeyT,ValueT>> 
            void run(ValueHolderT value, ValueProcessor<KeyT, ValueHolderT> processor) {
        processor.doSomethingWith(value);
    }
}

public class Client {
    public static void test() {
        ValueHolder<String,BaseValue> value = null;
        ValueProcessor<String,ValueHolder<String,BaseValue>> processor = null;

        new Process().run(value, processor);
    }
}

...让我们说这发生在第1000个地方 - ＆gt;由于模板参数过多而导致代码混乱，但......

这实际上是不需要的，KeyT类型参数（我的样本中的String）已经为ValueHolder定义，只是为ValueProcessor复制。我会将我的代码编写如下（参见as KeyT），但不接受该语法。

public class ValueProcessor<ValueHolderT extends ValueHolder<? {{{as KeyT}}},?>> {
    public KeyT doSomethingWith(ValueHolderT value) {
        return value.key;
    }
}

问题 - 这在Java语法中是否可行？

从参数化通用参数反向推断参数类型

0 个答案: