Which type safety would have lost, had Generics supported the sub-typing? [duplicate]

Question

Consider the snippet:

Number[] numbers = {1, 2.3, 4.5f, 6000000000000000000L}; 

It's perfectly okay to do the above, Number is an abstract class.

Going ahead,

List<Long> listLong = new ArrayList<Long>(); listLong.add(Long.valueOf(10));  List<Number> listNumbers = listLong; // compiler error    - LINE 3  listNumbers.add(Double.valueOf(1.23)); 

Had Line 3 was designed to be compiled successfully, we would end up with a List of Numbers, i.e,

for(Number num: listNumbers ){     System.out.println(num); }  // 10 // 1.23 

which are all numbers.

I came across this in a book,

Generics doesn’t support sub-typing because it will cause issues in achieving type safety. That’s why List<T> is not considered as a subtype of List<S> where S is the super-type of T

Which type safety would have lost in this specific case as discussed above, were the Line 3 was to be compile successfully?

Answer 1

List<Long> listLong = new ArrayList<Long>(); List<Number> listNumbers = listLong; 

So, listNumbers and listLong would be two references to the same list, if that was possible, right?

listNumbers.add(Double.valueOf(1.23)); 

So, you would be able to add a Double to that list. listLong, of type List<Long>, would thus contain a Double. The type-safety would thus be broken.

Answer 2

If that was the case, then we could add other different subtypes of Number into listNumbers, which must be forbidden.

Imagine you're now inserting objects of type Double and Long, and later you try to use Long#reverse. Your code will compile but of course will fail at runtime (bad) the first Double it'll come through.