Some hints on how different JAVA generics appear to be to .NET generics

A tss entry caught my curiosity as it was talking about a “generics puzzle” in JAVA. Finally, I thought, an example-based look at how JAVA generics differ from their .NET pendant? Indeed, the puzzle turns out to not be one in e.g. C#.

If the intent is to be able to create instances of a provided type argument, we need a constrain on the provided type argument to provide a parameterless constructor…

class GenericCheck<T> where T : new() {
public T Instance {
get {
return Activator.CreateInstance<T>();

Beware, though that if T has no default constructor, construction will fail with a MissingMethodException. Funny enough though, the Activator’s method has no constraint on T, which it could easily implement:

public V CreateInstance<V>() where V : new() ...

Apart from that you could also construct types that have no default constructor. Just sprinkle in some reflection. The type in question is easily accessed with typeof(T)…

class GenericCheck<T> {
public T Instance(string name, int age) {
Type t = typeof(T);
ConstructorInfo info = t.GetConstructor(
new Type[] { typeof(string), typeof(int) });
if (info != null) {
return (T)info.Invoke(BindingFlags.CreateInstance,
null,new object[] { name, age },null);
return default(T);
public static void Test() {
GenericCheck<Person> gp = new GenericCheck<Person>();
Person p = gp.Instance("martha", 24);

What you don’t get with this approach is type safety, and you’ll probably have a performance penalty, but that’s another subject. So, no puzzles to be seen…