¿Cuál es la diferencia entre <? extiende Foo> y <Foo>

Parece que tengo un malentendido sobre la diferencia entre <Foo>y <? extends Foo>. Según tengo entendido, si tuviéramos

ArrayList<Foo> foos = new ArrayList<>();

Esto indica que Foose pueden agregar objetos de tipo a esta lista de matriz. Como las subclases de Footambién son de tipo Foo, también se pueden agregar sin error, como lo ilustra

ArrayList<Foo> foos = new ArrayList<>();
foos.add(new Foo());
foos.add(new Bar());

donde Bar extends Foo.

Ahora, digamos que me había definido fooscomo

ArrayList<? extends Foo> foos = new ArrayList<>();

Mi comprensión actual es que esto se expresa some unknown type that extends Foo. Supongo que esto significa que cualquier objeto que sea una subclase de Foose puede agregar a esta lista; lo que significa que no hay diferencia entre ArrayList<Foo>y ArrayList<? extends Foo>.

Para probar esto, intenté escribir el siguiente código

ArrayList<? extends Foo> subFoos = new ArrayList<>();
subFoos.add(new Foo());
subFoos.add(new Bar());

pero se le solicitó el siguiente error de compilación

no suitable method found for add(Foo)
method java.util.Collection.add(capture#1 of ? extends Foo) is not applicable
(argument mismatch; Foo cannot be converted to capture#1 of ? extends Foo)

no suitable method found for add(Bar)
method java.util.Collection.add(capture#2 of ? extends Bar) is not applicable
(argument mismatch; Bar cannot be converted to capture#2 of ? extends Bar)

Según mi comprensión actual, puedo ver por qué no podría agregar un Fooa una lista de <? extends Foo>, porque no es una subclase de sí mismo; pero tengo curiosidad por saber por qué no puedo agregar un Bara la lista.

¿Dónde está el agujero en mi entendimiento?

Como has descubierto por ti mismo, ArrayListdeclarar como ArrayList<? extends Foo> subFoos = new ArrayList<>();no sería muy útil.

Para ver la utilidad de <? extends T>considerar esto:

List<Foo> collect( List<? extends Foo> a1, List<? extends Foo> a2 )
{
    List<Foo> collected = new ArrayList<>();
    collected.addAll( a1 );
    collected.addAll( a2 );
    return collected;
}

que luego se puede usar de la siguiente manera:

List<Foo> foos = collect( new ArrayList<Foo>(), new ArrayList<Bar>() );

o como sigue:

List<Foo> foos = collect( new ArrayList<Bar>(), new ArrayList<Foo>() );

tenga en cuenta que nada de lo anterior hubiera funcionado si el collectmétodo se hubiera declarado de la siguiente manera:

List<Foo> collect( List<Foo> a1, List<Foo> a2 )