Instantiate generic class from a String variable (Java)

Question

I am trying to instantiate a class given a String in Java. Something like this:

// Pseudocode
String name = "MyClass";
SomeClass<name> sc = new SomeClass<name>(parameter);

In my case, the constructor takes a Class<E> type. So I would pass MyClass.class. Ideally, take the string and append .class. It would turn out like this:

SomeClass<name> sc = new SomeClass<name>(name.class);

I was looking at the answer here: Create new class from a Variable in Java but could not get it to work. Using the info from that link, I tried this:

String name = "MyClass";
Class className = Class.forName(name);
className param1;
Constructor con = className.getConstructor(className.class);
SomeClass<className> sc = con.newInstance(param1);

Of course, this doesn't work. How would I go about achieving this?

Answer 1

Generics are mostly a compile-time tool helping the compiler spot casting errors. Due to type erasure most of the generic information is lost at runtime - besides some basic information in reflection data (which doesn't really help you here).

Let's assume your constructor looks like this:

public SomeClass( Class<T> param ) { ... }

Due to type erasure at runtime it looks like this (when being called):

public SomeClass( Class param ) { ... }

As you can see there's no generic information so to get it you'd use SomeClass.getConstructor( Class.class ).

Then you can invoke it using newInstance( Class.forName("java.lang.String") ). Again you see that you're basically able to pass in any class as a parameter which is due to generics being a compile-time tool, i.e. the compiler applies those checks while the runtime trusts the compiled code.

If you need to employ any boundaries you'd need to either use a different approach or check for the correct class being passed inside the constructor (e.g. by using the method Class#isAssignableFrom()).

When assigning the created instance to a variable you need to use a wildcard, i.e. SomeClass<?> sc, or a raw type, i.e. SomeClass sc (I'd suggest using the wildcard). Of course the compiler then can't allow you to call any method that is only present in some classes (e.g. in MyClass) since it simply doesn't know (and it can't know the class definition from just a name).

Edit:

In the hope of being able to clarify the last part I'll try and add another example.

Assume MyClass had a method foo() and SomeClass has a method T getTypeInstance(). If your variable type would be SomeClass<MyClass> sc you could do a call sc.getTypeInstance().foo() since the compiler knows that T is bound to MyClass.

However, when using reflection that information is lost, i.e. since you'd have to use SomeClass<?> sc the compiler would not know the return type of getTypeInstance() and thus wouldn't allow calls to foo().

If you know that all classes you could pass as a parameter implement the same interface you could do something like SomeClass<CommonInterface> sc which would compile since Constructor#newInstance() returns a raw type and thus compiler checks are disabled here. In that case you could add foo() to CommonInterface and be able to call it - at least unless you break the code.

The problem with the above is that you could also pass String.class to the constructor, which the compiler and runtime would allow but which is still wrong since String doesn't implement CommonInterface. Hence you'd get exceptions when trying to create the instance, cast it to CommonInterface or call foo() on it - unless you add a check in your constructor that rejects any parameter that isn't a class being assignable to CommonInterface (e.g. by checking CommonInterface.class.isAssignableFrom( param )).

Answer 2

Assuming your generic class looks something like this:

public GenericClass(Class<T> param) {
    System.out.println(param.getName());
}

Your code could look like this:

@SuppressWarnings("unchecked")
public static void main(String[] args) throws Exception {
    String type = "java.lang.String";
    Class g = GenericClass.class;
    Constructor c = g.getConstructor(Class.class);
    GenericClass<?> genericClass = (GenericClass<?>) c.newInstance(Class.forName(type));
}

And you'll see in the console that it prints "java.lang.String".

This works because in reflection, everything must have a type, and since generics have no type in compilation, it shows up as java.lang.Class, not java.lang.Class<T>. So, to get the constructor, you must tell it it find the constructor taking a class object. Then, simply use Class.forName to find the class in type, and call the constructor, passing in that class.

Answer 3

I see some errors in your code:

What is: className param1; ? You can't use className that is an object of class Class as a type.

The invokation:

Constructor con = className.getConstructor(className.class);

returns a constructor of the class "className" with a parameter of type "className". Is that your request? (For example if your class is ArrayList is the constructor taking 1 argument of type ArrayList)

The code:

SomeClass<className> sc = con.newInstance(param1);

Is syntactically not correct. The method newInstance returns an Object of type T. Try to assign it to a variable of type Object.

---

Here is how your code should seems:

String name = "MyClass";
Class className = Class.forName(name);
String param1 = "something";
// Using a constructor that use a String as parameter
Constructor con = className.getConstructor(String.class); 
Object sc = con.newInstance(param1);