Why can a generic list be casted to its type parameter

Question

Why does the following code compile?
Why is it allowed to cast a generic list to its type parameter if the parameter is an interface but not a super-interface of the generic?

What does this mean?

//Connection can be substituted by any interface
List<Connection> list = null;
Connection c = (Connection) list; 

Answer 1

It compiles but it will fail at execution time.

Static casting is one way for a developer to tell the compiler I know what I am doing here - I will handle the typing of these variables myself. The compiler will not stop you from doing something that will throw an exception at execution time.

Answer 2

That has nothing to do with the type parameter. This works as well:

List<String> list = null;
Connection c = (Connection) list; 

It's possible because List is an interface type. It would be possible for the list reference to hold an object that both implements the List interface and is also a Connection (whatever that is, class or interface), and for which the cast therefore works.

Thus, since the cast could work, the compiler allows it. It will only reject casts that are theoretically impossible, i.e. which involve concrete types in separate inheritance hierarchies:

    JComponent c = null;
    ArrayList l = (ArrayList) c;

You can look up the exact rules for what types of casts are legal at compile time in the Java Language Specification - it's about 30 lines of dense language lawyering.

Answer 3

Same thing, like with the other typecasting. You are allowed to cast almost any Object to any other. Compilers do not allow the most idiotic typecasting (like List to String), but still - it's up to you to watch the typecasting. Generally, use

if(a instanceof bClass){
    ((bClass)a).doSomething(...);
}