What is more flexible ?

Question

Hi,
Reading the generics faq, I have encountered this text:
"In general, if you have an API that only uses a type parameter T as an argument, its
uses should take advantage of lower bounded wildcards (? super T). Conversely, if
the API only returns T, you�ll give your clients more flexibility by using upper bounded
wildcards (? extends T)."
Could anybody please explain me how would somebody benefit
by using this convention ? Any examples ?
Thanks,
Adrian

Answer 1

Hi Simu,
That's right - an excellent example :)
Moreover - I do understand what you write here
and why it's useful here. But according to what was
written in the sun's faq (let me quote it again):
"In general, if you have an API that only uses a type parameter T as an argument, its
uses should take advantage of lower bounded wildcards (? super T). Conversely, if
the API only returns T, you�ll give your clients more flexibility by using upper bounded
wildcards (? extends T)."
An example you could fit into this convention could be (let's quote again):
public static <T> List<? extends T> doSomething(List<? super T> l) {
   return new ArrayList<T>();  // what else could I put in here ? I can't
                                                   //put just anything since I don't know what the T
                                                   //is going to be, so no subtypes available ...
                                                  //as for formal method's parameter l - there isn't
                                                  //any other benefit  then being able to invoke eg:
                                                  // l.add() .... or is there something else ?
}So we accept a parameterized formal method's parameter whose
type parameter is bounded wildcard. I understand that it is useful
as we are able to call e.g.: l.add() But sometimes it is not that case
and we want to accept List<? extends T>. So why does author assume that
List<? super T> is in general better ? (Why is he assuming that in general
we want to be able to call parameter's methods which have type parameter
in its signature more often ?) And secondly, as I wrote as comment, what is
the benefit of RETURNING List<? extends T> ?
And have a look at what I wrote about copy method again:
Original from Collections:
public static <T> void copy(List<? super T> dst, List<? extends T> src) {}My propose:
public static <T> void copy(List<? super T> dst, List<T> src) {}They BOTH work.
Thanks for your patient :)
Cheers,
Adrian