What does the question mark in Java generics' type parameter mean?
generics, java
Solution
? extends HasWord
means "A class/interface that extends `HasWord`." In other words, `HasWord` itself or any of its children... basically anything that would work with `instanceof HasWord` plus `null`.
In more technical terms, `? extends HasWord` is a bounded wildcard, covered in Item 31 of Effective Java 3rd Edition, starting on page 139. The same chapter from the 2nd Edition is available online as a PDF; the part on bounded wildcards is Item 28 starting on page 134.
Update: PDF link was updated since Oracle removed it a while back. It now points to the copy hosted by the Queen Mary University of London's School of Electronic Engineering and Computer Science.
Update 2: Lets go into a bit more detail as to why you'd want to use wildcards.
If you declare a method whose signature expect you to pass in `List<HasWord>`, then the only thing you can pass in is a `List<HasWord>`.
However, if said signature was `List<? extends HasWord>` then you could pass in a `List<ChildOfHasWord>` instead.
Note that there is a subtle difference between `List<? extends HasWord>` and `List<? super HasWord>`. As Joshua Bloch put it: PECS = producer-extends, consumer-super.
What this means is that if you are passing in a collection that your method pulls data out from (i.e. the collection is producing elements for your method to use), you should use `extends`. If you're passing in a collection that your method adds data to (i.e. the collection is consuming elements your method creates), it should use `super`.
This may sound confusing. However, you can see it in `List`'s `sort` command (which is just a shortcut to the two-arg version of Collections.sort). Instead of taking a `Comparator<T>`, it actually takes a `Comparator<? super T>`. In this case, the Comparator is consuming the elements of the `List` in order to reorder the List itself.
Problem
This is a small snippet of code taken from some of the examples that accompany the Stanford Parser. I've been developing in Java for about 4 years, but have never had a very strong understanding of what this style of code is supposed to indicate. ``` List<? extends HasWord> wordList = toke.tokenize(); ``` I'm not worried about the details of the code. What I'm confused about is what exactly the generic expression is supposed to convey, in English. Can someone explain this to me?