Suppose a method taking a List<Object> accepted a List<Integer>. That would mean List<Integer> was a subtype of List<Object>. If that were true you could do this:

List<Integer> intList = new ArrayList<Integer>();
List<Object> objList = (List<Object>) intList;
objList.add("foo");
int a = intList.get(0);  // This would fail at runtime because intList.get(0) is a String.

So if you could cast a List<Integer> to a List<Object> you would lose the compile-time type safe safety that generics provide.

List<?> is not the same as List<Object>. List<?> is a List of some unknown type T. Since T is unknown it is not possible to add anything to a List<?> (except null). This is in complete contrast to a List<Object> where you can add anything.

As a general rule, List<Object> is very rarely what you need. Most of the time you want a List where all the items have the same type, like a List<Integer> or a List<String>. If you are writing a method where the type is not important, such as your example that just prints the items, the argument should have type List<?>.

You also are able to declare a upper bound. So you say :

List<? extends Foo> list

this will cause that you only are able to to things in the list which are subclasses of foo. in you case write extends Object. So Integer is a subclass an can be inserted.