Generic SuperType confusing

[Manoj Shekhawat]

Super generic type means, class or it's super class.

So IOException have Exception and Object as it's super classes. right?

Then why we get compiler error while trying to add Exception to the list of exception?

List<? super IOException> exceptions = new ArrayList<Exception>();

exceptions.add(new Exception()); // DOES NOT COMPILE
exceptions.add(new IOException());
exceptions.add(new FileNotFoundException());

And how come we add FileNotFoundException which is subclass of IOException.

This is from OCP Oracle® Certified Professional Java® SE 8 Programmer II book By: Jeanne Boyarsky; Scott Selikoff from Chapter 3.

[Tamas Szekeres]

Since this is a super generic type, it means that all four of these are valid:

List<? super IOException> objects = new ArrayList<Object>();
List<? super IOException> throwables = new ArrayList<Throwable>();
List<? super IOException> exceptions = new ArrayList<Exception>();
List<? super IOException> ioExceptions = new ArrayList<IOException>();

However, this is invalid:

List<? super IOException> fileNotFoundExceptions = new ArrayList<FileNotFoundException>(); // does not compile

You don't know which specific list out of the possible four will be assigned to the variable, so you must ensure that whatever you're putting into it is going to be compatible with all of them:

// New variable types!
List<Object> objects = new ArrayList<Object>();
objects.add(new Object());
objects.add(new Throwable());
objects.add(new Exception());
objects.add(new IOException());
objects.add(new FileNotFoundException());

List<Throwable> throwables = new ArrayList<Throwable>();
throwables.add(new Object());                   // does not compile
throwables.add(new Throwable());
throwables.add(new Exception());
throwables.add(new IOException());
throwables.add(new FileNotFoundException());

List<Exception> exceptions = new ArrayList<Exception>();
exceptions.add(new Object());                   // does not compile
exceptions.add(new Throwable());                // does not compile
exceptions.add(new Exception());
exceptions.add(new IOException());
exceptions.add(new FileNotFoundException());

List<IOException> ioExceptions = new ArrayList<IOException>();
ioExceptions.add(new Object());                 // does not compile
ioExceptions.add(new Throwable());              // does not compile
ioExceptions.add(new Exception());              // does not compile
ioExceptions.add(new IOException());
ioExceptions.add(new FileNotFoundException());

Therefore in this case you can only put objects which are the same as the class or its child classes, but not their parents: IOException, FileNotFoundException, etc.

By the way, this is the exact same reason why you cannot add any objects to a list with an extends generic type.

class A {}
class B extends A {}
class B2 extends A {}
class C extends B {}
class D extends C {}
class E extends D {}
class F extends E {}
class F2 extends E {}

List<? extends A> as = new ArrayList<A>();
List<? extends A> bs = new ArrayList<B>();
List<? extends A> b2s = new ArrayList<B2>();
List<? extends A> cs = new ArrayList<C>();
List<? extends A> ds = new ArrayList<D>();
List<? extends A> es = new ArrayList<E>();
List<? extends A> fs = new ArrayList<F>();
List<? extends A> f2s = new ArrayList<F2>();

There you do not have a most specific class that can possibly fit into any of these, as none of them are final and so can have child classes on their own that we might not even know about when we're writing our codes. If one of them were final, like String, you could have a most specific final class, but in this case there's no point using the ? extends struct, because there can not be any child classes.

[Manoj Shekhawat]

Thanks Tamas for such a long and detailed explanation. It's clear now. Thanks again...!!!