Question

One thing that irritates me about Java is the awful implementation of compile-time translation of generic type arguments.

I can observe and understand that the C# implementation is far better, but I’m confused as to how it works.

Essentially, how can you say:

T t = new T()

If you don’t know the type of T and therefore don’t know the constructor argument requirements?

I can see

Class<T> cl = T.class

or

T[] tarr = new T[0]

but I don’t see how you can really create a new instance of T if you don’t know the requirements of constructing it?

Answer 1

You can only do new T(); if T is constrained to have a plain, parameterless public constructor, for instance:

public class Foo<T> where T : new() {
    private myT = new T();
}

Additionally, there is no way to specify that any other sort of constructor exist. This is not possible:

// Doesn't work
public class Foo<T> where T : new(String, Int) {
    private myT = new T("Foo", 5);
}

To your other points, this is how you get the type of T at runtime:

var tType = typeof(T);

and creating an array of T doesn’t actually create any instances (unless T is a value type, in which case it creates the default value of that type):

// Space for 32 T's, but nothing in the array.
// If T is a value type, like an int for instance, 
// each one would have the default value (0 for int, for example)
var arrayOfT = new T[32];