Java class loader for new instance

Question

I at one time used class forname newinstance but newinstance is deprecated. I wanted to be able to pass a class name as a string and be able to load a class, so I came up with:

    public static Object getClass(String myclass) throws ClassNotFoundException,
        NoSuchMethodException,
        InstantiationException,
        IllegalAccessException,
        IllegalArgumentException,
        InvocationTargetException {
    Class clz = Class.forName(myclass);
    return clz.getDeclaredConstructor().newInstance();

}

Which works good. And usage is:

    Jim.Newpager apager = (Jim.Newpager) Jim.Jiminject.getInstance().getClass("Jim.Newpager");

Does that look alright?

The whole class that does the inject is:

package Jim;

import java.lang.reflect.InvocationTargetException;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;


public class Jiminject {

    private static final Jiminject instance
            = new Jiminject();

    private Jiminject() {

    }

    public static Jiminject getInstance() {
        return instance;
    }


    public static Object getClass(String myclass) throws ClassNotFoundException,
            NoSuchMethodException,
            InstantiationException,
            IllegalAccessException,
            IllegalArgumentException,
            InvocationTargetException {
        Class clz = Class.forName(myclass);
        return clz.getDeclaredConstructor().newInstance();

    }
}

I use for Tomcat, all works good.

Answer 1

The concept is odd to me and I've made a comment about clarifications. In the mean time... a few pointers about code style.

The method name getClass suggests that you are getting a class, when in fact you are returning an instance. To better convey the purpose of the method, you should rename it to instantiateClass or newInstance etc.

The name prefx my (as in myclass parameter) is the de facto naming style when you can not bother to think about an actually good and useful name. Never use the "my" prefix. Ever. It is always a sign that you are skipping an important part of your work. In this case, just use className, because that's what the parameter represents.

The getClass method is a helper method that shortens the instantiation boiler plate. It would be helpful to the user if you also wrapped the exceptions into a single generic exception that signals failure to instantiate the class. They all result in the same action in you code, right? So no point in making the caller handle each case separately.

Since you are using the getClass method via the instance retrieved with getInstance() there is no point in getClass to be static. Either drop the static qualifier of delete the getInstance() method.

Package names are writte in lower case letters. So make it jim instead of Jim. Capitalized initial letter is reserved for classes so the "pearl necklace" Jim.Jiminject.getInstance makes me look for a class named Jim to get to the start of the code.

Answer 2

Class#newInstance is deprecated as it does not handle the checked exceptions of the default constructor call. So getting the default constructor (no arguments) and using Constructor#newInstance is the correct way.

Only problem: there might not exist a default constructor, only some constructor with parameters.

public static Object instantiate(String classFullName) throws ClassNotFoundException,
        NoSuchMethodException,
        InstantiationException,
        IllegalAccessException,
        IllegalArgumentException,
        InvocationTargetException {
    Class<?> type = Class.forName(classFullName);
    return type.getDeclaredConstructor().newInstance();
}

You might use Exception instead of the entire list.