Generics -> Polimorphism -> Misunderstanding or Just how it works

Question

Let's consider block of code:

List<List<Object>> list = new ArrayList();
list.add(new ArrayList<Object>); //Line 2
list.add(new LinkedList<Object>); //Line 3
list.add(new LinkedList<Date>); //Line 4

Ok:

1. As far as I know polimorphic assigment DO NOT work within Generics

   Question: But in the line: 2, 3, 4 Is there List, ArrayList, LinkedList are not generic for collection with name list??

2. Line 4 won't compile, regardless of Date is subtype of Object

   Question: Back to the question 1, Is this means that Object and Date is case of polymorphism and generics???

Can understand it. Please help.

---

And one more question:

List list = new ArrayList<String>();
  list.add(new Integer(1));
  System.out.print(list.get(0));

Output: 1

Will compile, means no type safety. Why? Even if List list- raw type, and ArrayList<String> parametrized type, any way is useless. Why?

Answer 1

FIRST QUESTION:

So the rule is that: a subclass can do everything that the superclass can do (and maybe more).

A<X> is a subclass of B<X> if A is a subclass of B

This is because A can do anything that B can do. Wherever you can use B<X> you can use A<X>.

For example:

List<Object> lo
ArrayList<Object> alo

ArrayList<Object> alo can do everything List<Object> lo can do so it is a subclass.

But:

A<X> is not a subclass of A<Y>, even if X is a subclass of Y

This is because A<X> cannot do everything that A<Y> can do.

In the case of:

List<Object> lo
List<Date> ld

List<Object> lo can add any object to lo, but List<Date> ld can only add dates, so it can't be a subclass.

SECOND QUESTION:

List list = new ArrayList<String>();
list.add(new Integer(1));

Yes - this is very bad and doesn't work. That is why you get a warning.

The List declaration is the significant part here in determining the type of list and what you can do with it. At runtime, the ArrayList<String> just looks like an ArrayList due to something called type-erasure, so that will not prevent bad things being added either.

List is a raw type. References to generic type List should be
parameterized

CAVEAT:

The statement a subclass can do everything that the superclass can do is a general statement of design intent and not intended to be literally true. You can, of course, find counter examples.

Answer 2

As far as I know polimorphic assigment DO NOT work within Generics

That's wrong. A reference of type ArrayList<E> and a reference of type LinkedList<E> are both subtypes of a reference of type List<E>.

Line 4 won't compile, regardless of Date is subtype of Object

A reference of type LinkedList<T> is not a subtype of a reference of type List<E> (Even if T is a subtype of E)

Even if List list- raw type, and ArrayList parametrized type

You declare a reference of type List. This is conceptually the same as declaring a reference type of List<Object>. Calls to any method (weather static or instance method) are resolved at compile time using the reference type. Since the reference type is List (i.e a raw list), the compiler will allow you to add an object of any type to the list. When the class is compiled, the statement ArrayList<String> is converted to ArrayList by the compiler. This is known as type-erasure. This also the reason why you don't face any issues at runtime.

Answer 3

As far as I know polimorphic assigment DO NOT work within Generics

Actually you are talking about Generics and Inheritence.

so if you have List<Animal> i.e list of animal you can add any animal under list like cat,dog but you can cant assign list of dog to list of animal

Here is the example

psvm{
List<Dog> list1 = new ArrayList<Dog>();
list1.add(new Dog());
method1(list1);// compilation error
}

public static void method1(List<Animal> list1) {
list1.add(cat); // Good
list1.add(dog); // Good
}

So you did not get any error on line 2/3 but line 4 will give compilation error because new LinkedList<Date> is not child of List<Object>

UPDATE:- if you want to assign list of dog to list of animal then see below

psvm{
List<Dog> list1 = new ArrayList<Dog>();
list1.add(new Dog());
method1(list1);// good
}

public static void method1(List<? extends Animal> list1) {
list1.add(cat); // compilation error
list1.add(dog); // compilation error
}