为什么Java在泛型中有下限？(Why does Java have lower bounds in generics?)

 我正在尝试设计自己的编程语言，并且正在考虑泛型。 我已经在Java工作了很长一段时间，并且知道extends和super泛型边界。 
 
 我正在阅读这篇文章并试图了解下限的必要性。 
 
 在我的语言中，我打算像常规字段一样进行泛型，如果你说List<MyObject> ，你可以存储MyObject或MyObject任何子类型。 有道理吗？ 
 
 在帖子上，它们具有以下类层次结构： 
 
class Person implements Comparable<Person> {
  ...
}

class Student extends Person {
  ...
}
 
 然后他们有一个排序方法： 
 
public static <T extends Comparable<T>> void sort(List<T> list) {
  ...
}
 
 我的想法是，你应该能够将List<Student>发送给这个方法。 当Student扩展Person ， compare方法将由它的超类Person 。 
 
 
 
 出现错误消息的原因是编译器将sort方法的type参数推断为T：= Student，并且该类Student不是Comparable<Student> 。 它是Comparable<Person> ，但是不符合方法排序的类型参数的界限所强加的要求。 要求T （即Student ）是Comparable<T> （即可Comparable<Student> ），实际上它不是。 
 
 
 以上对我没有任何意义......你应该能够做student.compare(person) ，为什么这不起作用？ 
 
 也许它说Student应该实施它自己的可比方法，以便Student在比较中有发言权？ 你不需要做任何特殊的事情，只需覆盖Person的方法。 您将无法保证与另一位Student进行比较，但可以使用instanceof进行检查。 
 
 这里有什么我想念的吗？ 
 
 毕竟这个想法，我现在想知道extends的目的是什么。 根据我的理解，在List<MyType> ，您只能放入MyType ，而不能放入任何子类。 如上所述，这对我没有任何意义，你应该能够像字段一样将任何子类放在列表中。 
 
 我应该说清楚这一点，它不是“为什么它不能在Java中工作”，而是“为什么它在泛型理论中不起作用”。 我只是标记了java，因为这是我进行比较的地方。 

I'm trying to design my own programming language, and am thinking about generics. I've been doing Java for quite a while now and know about the extends and super generic bounds.
 
I'm reading this post and trying to understand the need for the lower bounds.
 
In my language, I am planning to do generics the same way as a regular field, if you say List<MyObject>, you can store either a MyObject, or any subtype of MyObject. Makes sense right?
 
On the post, they have the following class hierarchy:
 
class Person implements Comparable<Person> {
  ...
}

class Student extends Person {
  ...
}
 
They then have a sort method:
 
public static <T extends Comparable<T>> void sort(List<T> list) {
  ...
}
 
What I think, is that you should be able to send a List<Student> to this method. As a Student extends Person, the compare method would be handled by it's superclass, Person.
 
 
 
The reason for the error message is that the compiler infers the type parameter of the sort method as T:=Student and that class Student is not Comparable<Student> . It is Comparable<Person> , but that does not meet the requirements imposed by the bound of the type parameter of method sort. It is required that T (i.e. Student ) is Comparable<T> (i.e. Comparable<Student> ), which in fact it is not.
 
 
The above doesn't make any sense to me...you should be able to do student.compare(person), so why doesn't this work?
 
Maybe it's saying that Student should implement it's own comparable method so that Student has a say in the comparison? You don't need to do anything special, just override Person's method. You won't be able to guarantee you are comparing to another Student, but that can be checked with instanceof.
 
Is there something I'm missing here?
 
And after all this thinking, I'm now wondering what the purpose of extends is. From my understanding, in a List<MyType>, you can only put a MyType in, not any of it's subclasses. As mentioned above, this doesn't make any sense to me and you should be able to put any subclass in the list like a field.
 
I should probably make this clear, it's not "why doesn't it work in Java", but "why doesn't it work in generics theory". I just tagged java because that is where I'm making my comparisons.

原文：https://stackoverflow.com/questions/35714431