Java: Why am I able to have a reference to a non-null array of concrete parameterized types?

Question

I was surprised, but ... this compiles:

public <T extends Database> ColMetaData<T>[] getTableColumnsAsEnums() {
            Class<? extends ColMetaData> cls = this.columnsEnumToken();
            return cls.<ColMetaData<T>[]>getEnumConstants(); }

Here is the method for columnsEnumToken:

// Returns a class token for an enum class
public Class<? extends ColMetaData> columnsEnumToken()  { 
    return this.e_colsToken; 
}

(I guess I can see why the second line below doesn't compile)

Some questions:

• Is this method "type safe"?

• Why does this line compile:

  Class<? extends ColMetaData> cls = this.columnsEnumToken();

  But this one fails to compile because of incompatible types:

  Class<? extends ColMetaData<T>> cls = this.columnsEnumToken();

• Why is it legal for method getTableColumnsAsEnums() to return an array of a concrete parameterized type, ColMetaData<T>[]. I had thought that these were strictly verboten because there was no runtime way to have them operate type safely.

Answer 1

Class

Theoretically, a Class cannot represent a parameterized type. For example, there is no class for List<String>, so you should not write Class<List<String>>, but only Class<List>.

However Class<? extends List<String>> could make sense. For example, if we have

    public class MyStringList extends ArrayList<String>{}

MyStringList.class is a Class<MyStringList> which is a Class<? extends List<String>>

Generic Array

There's nothing wrong with generic array type, it's just that Java forbids us to instantiate any... But the reason isn't very convincing. You can just go ahead and create one through casts, as long as you know it's safe.

Actually, there is a straightforward way in Java to create a generic array. When we call a method with varargs X..., an X[] object will be created - and X can be any type.

Compatible assignment

Apparently for some backward compatibility reason, we can assign a List[] to List<String>[]. That's why you can return a ColMetaData[] object while the return type is ColMetaData<T>[].

Answer 2

Think about what ColMetaData<T>[] represents. In Java, generics are strictly a compile time issue. At run time, they cease to exist. So what you're really telling the runtime is that you have an array of ColMetaData instances, which indeed is a concrete type. This is different, however, than using an arbitrary type for the array. The array type is still ColMetaData, and Java can determine this at compile time. Then the compiler needs only to track that the instances you store use the correct generic type.