Understanding wildcard-constraint

Question

I can work with basic generic expression but the wildcard-constraints just mess with my mind.

Info: Student extends Person and Person extends Animal

 List<? super Animal> aList= new ArrayList<>();

       // does not compile as expected, 
       // since the list is restricted to something that has Animal as superclass.
       // aList.add(new Object()); 

    aList.add(new Animal()); // I can add animal
    aList.add(new Person()); // I can add Person
    aList.add(new Student()); // I can add Student

    Animal a = new Animal();
    Animal b = new Animal();
    Person p = new Person();
    Student s = new Student();
    // test
    a = b; //I can assign an animal to another animal
    a = p; // I can assign a person to an animal
    a = s; // I can assign a student to an animal

    Animal animal = aList.get(0); // DOES NOT COMPILE, WHY ?

QUESTION: I don't understand why the last assignment does not work. The examples above show, that anything in that list is definitely an animal, yet I can't get an animal from that list.

MORE SPECIFIC: When I know that I can add only types which have Animal as superclass, why can't I expect to remove objects from type Animal ?

FACT: I can ONLY add objects which extend Animal! I just tried to add a car object and it does not work !

I am starting to doubt my sanity, I hope you can help me. Thank You

Additionally:

Object animal = aList.get(0); // works

Why does this statement work even though I know that I can't add an Object-Type ?

SOLUTION: (Based on the accepted answer)

I misunderstood the meaning of <? super Animal>

What I thought it means: Any class which has Animal as superclass.

What it (apparently) means: Any Class which is superclass of Animal.

Therefore a List might also contain objects of type Object which is why Animal animal = aList.get(0); fails.

Cheers

Answer 1

The other answers here are right, but not stated clearly enough, which is where the confusion is coming from.

A List<? extends Animal> does not mean "A list of things that all extend Animal." It means "A list of some type T, which I won't tell you what it is, but I know that T extends Animal." (In type theory, these are called existential types -- there exists a type T for which our List is a List<T>, but we don't necessarily know what T is.)

The difference is important. If you have "a list of things that all extend Animal", then it would be safe to add a Dog to the list -- but this is not what wildcards express. A List<? extends Animal> means "List of something, where that something extends Animal". It might be a List<Animal>, or a List<Dog>, or a List<Cat> -- we don't know. So we have no reason to think that its safe to add a Dog to that list -- because maybe my List is a List<Cat>.

In your example, you have a List<? super Animal>. This means, a list of some type T, where T is one of the supertypes of Animal. It might be a List<Object>, or a List<Animal>, or if Animal has a supertype HasLegs, it might be a List<HasLegs>. Here, it's safe to put a Dog into this list -- because whatever its a List of, Dog is definitely one of those (Animal, Object, etc), but when you take something out of the list, you have no idea whether its a Dog, an Animal, or just an Object.

Answer 2

List<? super Animal> aList is reference which can be used to handle List<Animal> , it can also be any superclass of Animal such as List<Object>.

In other words List<? super Animal> aList
- is not reference to some list which can store any supertype of Animal.
+ it is reference to list of some specific type which is supertype of Animal (including Animal itself) but you don't know which type it is exactly.

So it could be

List<Object> someList = new ArrayList<>();
someList.add(new Car());//OK since Car is a Object
List<? super Animal> aList = someList;// OK since Object is supertype of Animal

Because of that, code

Animal a = aList.get(0);//and where did that Car come from?

is not safe. Only safe type to store the result of get(0) is Object so you either need

Object o = aList.get(0);

or if you want to make sure that get will return Animal, change the type of your aList reference to List<Animal> or even List<? extends Animal>.

Answer 3

List<? super Animal> means a list of any superclass of Animal. If Animal is a subclass of LivingThing, then List<? super Animal> can be a list of Animals, a list of LivingThings, or a list of Object. In the last two cases, the assignment Animal x = aList.get(0) would of course be illegal, because you cannot assign a LivingThing to a reference of type Animal.

Consider the following method (it will not compile):

void f(List<? super Animal> list) {
    Animal a = list.get(0); // line 1
    list.add(new Object()); // line 2
}

The method call

List<Object> list = new ArrayList<>();
list.add(new Object());
f(list);

is correct, because Object is a superclass of Animal. However, if the method f would compile, you would try to assign in Line 1 an Object to an Animal reference, so it would not be type safe.

On the other, hand consider the method call:

f(new List<Animal>());

If the method f would compile, we would now be adding an Object instance to a list which should only contain Animals.

That's why both Line 1 and Line 2 are not allowed. If you have a class

public class A<T> {
    public put(T in) { } 
    public T get() { } 
}

then for the type A<? super Animal> the method get will return a Object (not an Animal), while the method put expects a parameter of type Animal.