Creating an instance using the class name and calling constructor

java

reflection

constructor

security

byAnton Shumikhin·Feb 3, 2025

Create an instance from a class name by leveraging the power of Java's reflection. This is accomplished by utilizing Class.forName() to find the class and getDeclaredConstructor() to access the constructor. Cap it off by instantiating with .newInstance() after invoking the constructor. Be vigilant about catching reflection-related exceptions like ClassNotFoundException, NoSuchMethodException, and InvocationTargetException.

Example for a class with a single String parameter constructor:

String className = "com.example.MyClass";
Class<?> clazz = Class.forName(className);
Constructor<?> constructor = clazz.getDeclaredConstructor(String.class);
// Instantiation time! Like creating a spellbinding potion in Hogwarts
Object instance = constructor.newInstance("arg");

Java 9 and fancy new versions:

Object instance = clazz.getDeclaredConstructor().newInstance();

Imports to not forget:

import java.lang.reflect.Constructor;

Such approach lends itself to virtually any constructor variant by simply passing the appropriate parameter types to getDeclaredConstructor().

Behind the scenes: Under the hood, dealing with constructors

For constructors hiding in plain sight (not publicly accessible), consider getDeclaredConstructor(). This method helps you access private constructors. Remember, for security and encapsulation, you might need to call setAccessible(true) on the Constructor object.

Constructor<?> privateConstructor = clazz.getDeclaredConstructor();
privateConstructor.setAccessible(true); // Like picking the castle's lock, sneakily bypassing access checks 
Object instance = privateConstructor.newInstance();

Be aware, however, this practice might not make your OOP teachers proud as it could potentially violate encapsulation principles and should be used with discretion within the context of your application’s security model.

Navigating the Reflection toolbox: various methods, scenarios, and tricks

If your class is pampered with multiple constructors, but you're particularly interested in the no-argument constructor, feel free to avoid specifying parameter types.

Object instance = clazz.getDeclaredConstructor().newInstance();

Feeling adventurous? Want to handle varargs of constructor parameters on the go?

Constructor<?> varArgsConstructor = clazz.getConstructor(Object[].class); // For varargs, like ordering a pizza with 'extra toppings'
Object instance = varArgsConstructor.newInstance(new Object[] { "str", 1, true });

Even though reflection has a cool ring to it, it comes with a cost. Keep in mind the overhead and security implications. Reach for it when other options are exhausted i.e., when using new directly or design patterns like Factory seem like round pegs in square holes.

Reflection: When and Where (not to use it)

Reflection is not a one-trick pony; it shines in dynamic scenarios. Picture a plugin system or modular frameworks where classes aren’t known until runtime. When regular programming feels like fighting with one hand tied behind your back, reflection comes to the rescue!

String serviceClass = config.getServiceClassName(); // Config file driven approach
Class<?> serviceClazz = Class.forName(serviceClass);
Service serviceInstance = (Service) serviceClazz.getDeclaredConstructor().newInstance();

Yet, reflection isn't for every day! Here are some caveats:

Performance: reflection is like doing yoga, flexible but not fast.
Security: reflective operations mean managing permissions.
Exceptions: reflective operations throw checked exceptions. You can't ignore them!
Maintainability: excessive use of reflection is the root of some migraines.

Frameworks like Spring and Hibernate use reflection under the hood for inversion of control (IoC) and ORM capabilities.

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); // Spring's version of 'Abracadabra'
MyBean bean = context.getBean("myBean", MyBean.class); // The bean is out of the bag

The complex nuances of reflection in these frameworks are usually hidden beneath the smooth surface of the framework's API.

explain-codes / Java / Creating an instance using the class name and calling constructor

Linked

Can I use Class.newInstance() with constructor arguments?



What to use instead of Class.newInstance()?



Should I initialize variable within constructor or outside constructor



Cannot refer to a non-final variable inside an inner class defined in a different method



Java Constructor Inheritance