Question

假设我有一个方法“mix”，它采用两个可能不同类型的T和S列表，并返回一个包含两者元素的List。对于类型安全，我想指定返回的List是R类型，其中R是T和S共有的超类型。例如：

List<Number> foo = mix(
    Arrays.asList<Integer>(1, 2, 3),
    Arrays.asList<Double>(1.0, 2.0, 3.0)
);

为了指定这个，我可以将方法声明为

static <R, T extends R, S extends R> List<R> mix(List<T> ts, List<S> ss)

但是如果我想在课程mix上使List2<T>成为实例方法而不是静态呢？

<R, T extends R, S extends R> List<R> mix ...

隐藏<T>实例上的List2，这样做并不好。

<R, T extends S&T, S extends R> List<R> mix ...

解决了阴影问题，但编译器不接受

<R super T, S extends R> List<R> mix ...

被编译器拒绝，因为下限通配符不能存储在命名变量中（仅用于? super X表达式）

我可以将参数移动到类本身，如List2<R, T extends R, S extends R>，但类型信息实际上没有业务存在于实例级别，因为它只用于一个方法调用，你必须重新每次要在不同参数上调用方法时，都会强制转换对象。

据我所知，没有办法用泛型做到这一点。我能做的最好的事情就是返回一个原始的List2并将其投射到调用点，就像引入泛型之前一样。有人有更好的解决方案吗？

Answer 1

如问题和评论中所述，以下签名是理想的：

<R super T, S extends R> List<R> mix(List<S> otherList)

但当然，R super T is not allowed by the language（请注意，polygenelubricants对链接帖子的回答是错误的 - 正如您的问题所示，这种语法有用例。）

没有办法在这里取胜 - 你只有几种解决方法可供选择：

使用原始类型的签名。不要这样做。
保持mix静态方法。这实际上是一个不错的选择，除非它因为多态相关的原因需要成为类接口的一部分，或者你计划将mix作为一种常用的方法，你认为保持静态是不可接受的。
以mix的签名限制过度限制，并记录调用者需要某些未经检查的强制转换。这类似于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
作为一种解决方法，将Optional<? extends T>转换为Optional<T>始终是安全的。将[上面的Optional实例]转换为Optional<Number>（其中Number是所需的输出类型）解决了这个问题：
Optional<Number> optionalInt = (Optional) getSomeOptionalInt();
Number value = optionalInt.or(0.5); // fine

不幸的是，总是可以安全地将List2<? extends T>投射到List2<T>。例如，将List2<Integer>强制转换为List2<Number>可能会将Double添加到仅应保留Integer的内容并导致意外的运行时错误。例外情况是List2是不可变的（如Optional），但这似乎不太可能。

但是，如果你小心并记录了类型不安全的代码并附带解释，那么你可以逃脱这些演员阵容。假设mix具有以下签名（和实现，为了好玩）：

List<T> mix(final List<? extends T> otherList) {

    final int totalElements = (size() + otherList.size());
    final List<T> result = new ArrayList<>(totalElements);

    Iterator<? extends T> itr1 = iterator();
    Iterator<? extends T> itr2 = otherList.iterator();
    while (result.size() < totalElements) {
        final T next = (itr1.hasNext() ? itr1 : itr2).next();
        result.add(next);
        final Iterator<? extends T> temp = itr1;
        itr1 = itr2;
        itr2 = temp;
    }

    return result;
}

然后您可能拥有以下呼叫站点：

final List2<Integer> ints = new List2<>(Arrays.asList(1, 2, 3));
final List<Double> doubles = Arrays.asList(1.5, 2.5, 3.5);

final List<Number> mixed;
// type-unsafe code within this scope
{
    @SuppressWarnings("unchecked") // okay because intsAsNumbers isn't written to
    final List2<Number> intsAsNumbers = (List2<Number>)(List2<?>)ints;
    mixed = intsAsNumbers.mix(doubles);
}

System.out.println(mixed); // [1, 1.5, 2, 2.5, 3, 3.5]

同样，静态mix的解决方案将变得更加清洁，并且没有类型安全的风险。我会确保有充分的理由不这样做。

Answer 2

我在你的问题中唯一不确定的是你是否已经知道这些子类扩展了哪种超类型，或者你想要一个完全通用的方法来传递任何给定超类的两个子类型。

在第一种情况下，我最近做了类似的事情，有一个抽象类和几个子类型：

public <V extends Superclass> List<Superclass> mix(List<V> list1, List<V> list2) {
  List<Superclass> mixedList;

  mixedList.addAll(list1);
  mixedList.addAll(list2);
}

后一种情况要复杂得多。我建议你重新考虑你的设计，因为混合方法在Superclass或知道超类及其子类的类中更有意义，因为你正在返回一个Superclass的List。

如果你真的想这样做，你必须将List2重构为List2并执行以下操作：

public <R, V extends R> List<R> mix(List<V> list1, List<V> list2) {
    List<R> mixedList;

    mixedList.addAll(list1);
    mixedList.addAll(list2);

    return mixedList;
}

使用generic来存储Java中的常用超类型

2 个答案: