最近我遇到了一个类似于这样定义的方法，但我并不完全理解它的用法：
public static <T, U extends T> T foo(U u) { ... }
// Baz is just the containing class of foo()
Number n = Baz.foo(1);
当 T 被推断为 Number 和 U（很可能）被推断为 Integer 时，这种方法优于例如这个方法定义：
public static <T> T bar(T t) { ... }
Number n = Baz.bar(2);
我认为，实际上只有当方法的类型参数出现在方法签名中作为参数化类型的类型参数时，这才有意义。
(至少我无法快速想出其他真正有意义的例子)
这也是你链接到的问题中的情况，在那里方法类型参数被用作AutoBean类的类型参数。
一个小更新：
根据问题和其他答案中的讨论，这个问题的核心可能是对类型参数使用方式的误解。因此，这个问题可以被视为Java函数声明中<T, U extends T>的含义的重复，但希望这个答案仍然有所帮助。
最终，使用<T，U extends T>模式的原因可以看作是参数化类型的继承关系，这在细节上可能会变得相当复杂。例如，为了说明最相关的点：一个List<Integer>不是List<Number>的子类型。
下面是一个示例，展示了它可以产生影响的情况。它包含一个“微不足道”的实现，它总是有效的（据我所知没有意义）。但当类型参数T和U也是方法参数和返回类型的类型参数时，类型约束变得重要。使用T extends U，你可以返回一个具有超类型作为类型参数的类型。否则，如// Does not work所示，你不能。
import java.util.ArrayList;
import java.util.List;
public class SupertypeMethod {
public static void main(String[] args) {
Integer integer = null;
Number number = null;
List<Number> numberList = null;
List<Integer> integerList = null;
// Always works:
integer = fooTrivial(integer);
number = fooTrivial(number);
number = fooTrivial(integer);
numberList = withList(numberList);
//numberList = withList(integerList); // Does not work
// Both work:
numberList = withListAndBound(numberList);
numberList = withListAndBound(integerList);
}
public static <T, U extends T> T fooTrivial(U u) {
return u;
}
public static <T, U extends T> List<T> withListAndBound(List<U> u) {
List<T> result = new ArrayList<T>();
result.add(u.get(0));
return result;
}
public static <T> List<T> withList(List<T> u) {
List<T> result = new ArrayList<T>();
result.add(u.get(0));
return result;
}
}
public static <T> List<T> withList(List<? extends T> l)，这样就可以适用于numberList = withList(integerList)。也许这只是Java语言中的一些冗余。 - LinoU 而不是类型 Something<U> 的情况下，我无法想象实际上会有什么区别。 - MC EmperorU extends T，在方法签名中通常可以（并且在此示例中也可以）使用? extends T。无法使用? extends T的情况是，例如，在List<T> copyAndAdd(List<U> us, U anotherU)中，必须知道U以用于第二个参数。 - Marco13当您想要返回超类型时，这非常方便；就像您在示例中展示的那样。
您以U为输入并返回T - 这是U的超类型; 声明这种关系的另一种方式是T super U，但在Java中不合法。
这应该是我实际意思的一个例子。假设一个非常简单的类，比如：
static class Holder<T> {
private final T t;
public Holder(T t) {
this.t = t;
}
public <U super T> U whenNull(U whenNull){
return t == null ? whenNull : t;
}
}
该定义的方法whenNull无法编译，因为在Java中不允许使用U super T.
相反，您可以添加另一个类型参数并倒置类型:
static class Holder<U, T extends U> {
private final T t;
public Holder(T t) {
this.t = t;
}
public U whenNull(U whenNull) {
return t == null ? whenNull : t;
}
}
使用方法如下：
Holder<Number, Integer> n = new Holder<>(null);
Number num = n.whenNull(22D);
static class Holder<T> {
private final T t;
public Holder(T t) {
this.t = t;
}
public static <U, T extends U> U whenNull(U whenNull, Holder<T> holder) {
return holder.t == null ? whenNull : holder.t;
}
}
甚至可以将这种方法改为静态方法。
对于现有的限制，您可以尝试执行以下操作：
Optional.ofNullable(<SomeSubTypeThatIsNull>)
.orElse(<SomeSuperType>)
U仍然可以分配给T，因此T就足够了，因为您可以将任何子类型传递给该方法。 - Lino第一种方法
public static <T, U extends T> T foo(U u) { ... }
这意味着T和U可以是不同的类型。即一个类型T和一个类型U，它是T的子类型。
以您的第二个示例为例：
public static <T> T bar(T t) { ... }
bar(T t) 必须返回与参数t相同的类型。它不能返回一个超类类型的对象，这只有在您的第一种变体中才可能。
T到底是什么。因为整个上下文都是泛型的。你不能确定X是否真的是T的子类型。 - LinoT 的对象，因为这在其签名中。然后，我可以通过 instanceof 检查它是哪种具体类型。它可能是 X，并且肯定是 T 的子类型。 - Thomas Kainradinstanceof实际上违背了泛型设计初衷。但是我同意，这种用法也是可以的。 - LinoNumber n = Baz.bar(2);
U extends T允许您返回仅为超类型类的对象，而不是子类！例如：class B { }
class C extends B { }
U extends T允许您返回B和C的实例。T单独时：只有C！U extends T而工作。Something<T>而不是T，这意味着它与Something<U>不是多态的，而T 是与U多态的。请看一下对OP的评论。 - RealSkepticOptional::orElse，我的错，它确实返回一个 T。 - Eugene private final T t;
public Holder(T t) {
this.t = null;
}
// 这样的方法无法编译// public <U super T> whenNull(U defaultValue){
// return t == null ? defaultValue : t;
// }
} 正如注释所说 - 这是不可能的。你需要添加另一个类型才能够实现，通过：static class Holder<T, U extends T> {... }`，但这会增加另一个类型参数...（续在下一条评论中） - EugeneList<T> 或 Optional<T> 这样的示例，这绝不是一个好主意，只是为了能够返回超类型。唯一的解决方案是添加一个静态方法，其中包含您上面的定义，以便能够实现该目标。 - Eugene
T有意义的方面。你能否提供真实签名的链接/内容？ - ThiloAutoBean<Object> autoBean = Foo.<Object, String>getAutoBean("delegate")。但是仍然不太有意义，因为单一泛型参数的结果是相同的。传递一个Object并收到一个Object。 - LinoT，而是Something<T>。 - RealSkepticString扩展了Object但是Something<String>不扩展Something<Object>。 - Lino<T，U extends T> T foo（U u）中的“特定”并没有什么不同，只需删除U并将其替换为T。 Marco13提供的示例与您的示例不完全相同：*它使用的是List <U>而不是简单的U*。 我同意，在parameterized type*（Something <U>）的上下文中，它会有意义，但我怀疑在type parameter*（U）的上下文中是否也是如此。 - MC Emperor