Ковариация и контравариантность для типов с подстановочными знаками

Не могли бы вы объяснить, почему это возможно:

import java.util.ArrayList;
import java.util.List;

public class Covariance {

    class A {
    }

    class B extends A {
    }

    class C extends A {
    }

    public void testSmth() throws Exception {
        List<? extends A> la = new ArrayList<A>();
        A a = la.get(0);
        // la.add(new B()); - doesn't compile

        List<? super B> lb = new ArrayList<A>();
        // lb.add(new A()); - doesn't compile
        lb.add(new B());
        Object object = lb.get(0);
    }

}

Я не понимаю, почему нельзя добавить что-то в ковариантный список la, но все еще можно добавить B в контравариантный список lb - но не от A до lb.

С моей точки зрения, должно быть возможно добавить все, что расширяет A, в список. Я вижу единственную причину, по которой я этого не делаю, потому что легко добавить C в список B, например

 List<B> lst = new ArrayList<B>();
 List<? extends A> lstB = lst;
 lstB.add(C); // this is valid for <? extends B> but list lst would contain instance of B.

Вероятно, то же самое верно и для контравариантности, например

 List<B> lst = new ArrayList<B>;
 List<? super C> lstC = lst;
 lstC.add(new C());
 Object obj = lstC.get(0);

Чего я не понимаю - почему это невозможно to do

 B b = lstC.get(0);

Очевидно, что на этом этапе super C будет классом B - Java не допускает множественное наследование.

Также мне не ясно, почему он запрещает

 lstC.add(new B());

.