Question

I noticed that a raw type of a generic class can take(point to) all different variations of the generic class and also all different variations of a generic class can take(point to) the raw type of the generic class. Why Java Generics behaves like that? Is it purely because of compatibility with the old versions of Java?

Example:

//Main.java
public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {

    List listRaw = new ArrayList();
    List<Student> listQualified = new ArrayList<Student>();
    List<?> listUnbounded = new ArrayList<Student>();
    List<? extends Student> listUpBounded = new ArrayList<Student>();
    List<? super Student> listDownBounded = new ArrayList<Student>();

    // List raw type can take all different variations of List
    List rawList1 = listRaw;
    List rawList2 = listQualified;
    List rawList3 = listUnbounded;
    List rawList4 = listUpBounded;
    List rawList5 = listDownBounded;

    // All different variations of List can take List raw type
    listRaw = rawList1;
    listQualified = rawList2;
    listUnbounded = rawList3;
    listUpBounded = rawList4;
    listDownBounded = rawList5;

    }

}

//People.java
public class People {

    public static class Student extends People {
    }

    public class HistoryStudent extends Student {
    }

    public class MathStudent extends Student {
    }
}

Answer 1

One of the main challenges the Sun engineers faced was to maintain the backward compatibility.
For example, if you are not able to assign:

List list = new ArrayList<Student>();

then, you wouldn’t be able to use older library methods.
i.e.:

List org.apache.commons.collections.ListUtils.intersection(List arg0, List arg1)

Also remember those types dissapear on runtime as described on http://docs.oracle.com/javase/tutorial/java/generics/erasure.html