Re: Warning unchecked call

However the problem with this is that you can't put anything into it,
not even Objects. For example, List<?> could hold a reference to
ArrayList<String>, so putting anything else, say a Number or even
Object, would be clearly wrong. Therefore the compiler prevents you
from doing so.

Wildcards aren't really for declaring variables, imo. They're for
enforcing constraints on parameter lists, and for type matching those
constraints inside such methods, which is where the confusion comes
from, I think. For example:

   <T> List<T> copyList( List<T> list ) {
     ...
   }

And not:

   <T> List<? extends T> copyList( List<? extends T> list ) {
     ...
   }

as the latter will be very difficult to use in practice. The first
declaration can be used as:

   List<String> strlst = ...
   List<String> strlst2 = copyList( strlst );

while the latter declaration forces:

   List<? extends String> strlst2 = copyList( strlst );

which is going to be much harder to deal with due to the compiler type
constraints I mention above.

So in summary I don't think a wildcard type for the List (or Vector)
would be of much use to the OP, or anybody else really. Object is
really the only way to go if he's putting things into it of various
types. Of course, if he is using a single type like String, then it's
much better to declare the List (or Vector) with a parameter of the
narrower type.