Question

我将尝试在以下简化示例中说明我的问题：

public class DataHolder<T> {
  private final T myValue;

  public DataHolder(T value) {
    myValue = value;
  }

  public T get() {
    return myValue;
  }

  // Won't compile
  public <R> DataHolder<R super T> firstNotNull(DataHolder<? extends R> other) {
    return new DataHolder<R>(myValue != null ? myValue : other.myValue);      }

  public static <R> DataHolder<R> selectFirstNotNull(DataHolder<? extends R> first,
                                                     DataHolder<? extends R> second) {
    return new DataHolder<R>(first.myValue != null ? first.myValue : second.myValue);
  }
}

这里我想编写泛型方法firstNotNull，它返回DataHolder参数化的T和this参数的类型参数other的公共超类型，所以后来我可以写例如

DataHolder<Number> r = new DataHolder<>(3).firstNotNull(new DataHolder<>(2.0));

或

DataHolder<Object> r = new DataHolder<>("foo").firstNotNull(new DataHolder<>(42));

问题是编译器拒绝了firstNotNull的这个定义，并且super T类型约束的一部分是非法的（语法上）。但是，没有这个约束定义也是错误的（显然），因为在这种情况下T和R彼此无关。

有趣的是，类似静态方法selectFirstNotNull的定义是正确的，后者按预期工作。是否有可能在Java类型系统中使用非静态方法实现相同的灵活性？

Answer 1

不可能这样做。 Guava的作者与Optional.or遇到了同样的问题。从该方法的文档：

关于泛型的注意事项：签名public T or(T defaultValue)是过度限制。但是，理想的签名public <S super T> S or(S)不是合法的Java。结果，一些明智的操作涉及子类型是编译错误：
Optional<Integer> optionalInt = getSomeOptionalInt();
Number value = optionalInt.or(0.5); // error

FluentIterable<? extends Number> numbers = getSomeNumbers();   
Optional<? extends Number> first = numbers.first();
Number value = first.or(0.5); // error
作为一种解决方法，施放它总是安全的 Optional<? extends T> to Optional<T>。铸造以上任何一种示例Optional个实例到Optional<Number>（其中Number是。Optional<Number> optionalInt = (Optional) getSomeOptionalInt(); Number value = optionalInt.or(0.5); // fine FluentIterable<? extends Number> numbers = getSomeNumbers(); Optional<Number> first = (Optional) numbers.first(); Number value = first.or(0.5); // fine 所需的输出类型）解决了这个问题：
DataHolder

由于Optional不可变，如{{1}}，因此上述解决方法也适用于您。

另请参阅：Rotsor's answer to Bounding generics with 'super' keyword

Answer 2

我认为没有任何简单且类型安全的方法可以做到这一点。我尝试了几种方法，但我找到的唯一工作方法是从super类型的通用实例开始，并使方法非常简单：

public DataHolder<T> firstNotNull(DataHolder<? extends T> other) {
    return new DataHolder<T>(myValue != null ? myValue : other.myValue);
}

现在您必须将调用更改为：

DataHolder<Number> r = new DataHolder<Number>(3).firstNotNull(new DataHolder<>(2.0));

您可能会认为这并不能真正回答您的问题，但这是您最简单的事情，或者更好地采用static方法。你肯定可以提出一些高度复杂（和类型不安全）的方法来做到这一点，但可读性应该是这里的主要问题。

Answer 3

尝试按以下方式更改方法：

      public <R> DataHolder<R> firstNotNull(DataHolder<? super T> other) {
        return new DataHolder<R>((R)(this.myValue != null ? myValue : other.myValue));
     }

警告：这会编译并给出大部分正确检查的外观，但并不完美。它将限制输入参数，但不限制输出。这不可能完美。在某些方面，你最好不要这样做，而不是给出被检查的错觉。以下是一些例子：

      DataHolder<BigDecimal> a = new DataHolder<>(new BigDecimal(34.0));
      DataHolder<Number> b = new DataHolder<>(new Integer(34));
      DataHolder<String> c = new DataHolder<>("");
      DataHolder<Number> p = a.firstNotNull(b); // WORKS (good)
      DataHolder<BigDecimal> q =  b.firstNotNull(a); // FAILS (good)
      DataHolder<BigDecimal> r =  b.firstNotNull(c); // FAILS (good)
      DataHolder<String> s =  a.firstNotNull(b); // WORKS (not good!!!)

如何在单个约束中使用方法和类类型参数？

3 个答案: