Instantiate an Inner Class With Reflection in Java

1. Overview

In this tutorial, we’ll discuss instantiating an inner class or a nested class in Java using the Reflection API.

Reflection API is particularly important in scenarios where the structure of Java classes is to be read and the classes instantiated dynamically. Particular scenarios are scanning annotations, finding and instantiating Java beans with the bean name, and many more. Some popular libraries like Spring and Hibernate and code analysis tools use it extensively.

Instantiating inner classes poses challenges in contrast to normal classes. Let’s explore more.

2. Inner Class Compilation

To use Java Reflection API on an inner class, we must understand how the compiler treats it. So, as an example let’s first define a Person class that we’ll use for demonstrating the instantiation of an inner class:

public class Person {
    String name;
    Address address;
    public Person() {
    }
    public class Address {
        String zip;
        public Address(String zip) {
            this.zip = zip;
        }
    }
    public static class Builder {
    }
}

The Person class has two inner classes, Address and Builder. The Address class is non-static because, in the real world, address is mostly tied to an instance of a person. However, Builder is static because it’s needed to create the instance of the Person. Hence, it must exist before we can instantiate the Person class.

The compiler creates separate class files for the inner classes instead of embedding them into the outer class. In this case, we see that the compiler created three classes in total:

The compiler generated the Person class and interestingly it also created two inner classes with names Person$Address and Person$Builder.

The next step is to find out about the constructors in the inner classes:

@Test
void givenInnerClass_whenUseReflection_thenShowConstructors() {
    final String personBuilderClassName = "com.baeldung.reflection.innerclass.Person$Builder";
    final String personAddressClassName = "com.baeldung.reflection.innerclass.Person$Address";
    assertDoesNotThrow(() -> logConstructors(Class.forName(personAddressClassName)));
    assertDoesNotThrow(() -> logConstructors(Class.forName(personBuilderClassName)));
}
static void logConstructors(Class<?> clazz) {
    Arrays.stream(clazz.getDeclaredConstructors())
      .map(c -> formatConstructorSignature(c))
      .forEach(logger::info);
}
static String formatConstructorSignature(Constructor<?> constructor) {
    String params = Arrays.stream(constructor.getParameters())
      .map(parameter -> parameter.getType().getSimpleName() + " " + parameter.getName())
      .collect(Collectors.joining(", "));
    return constructor.getName() + "(" + params + ")";
}

Class.forName() takes in the fully qualified name of the inner class and returns the Class object. Further, with this Class object, we get the details of the constructor using the method logConstructors():

com.baeldung.reflection.innerclass.Person$Address(Person this$0, String zip)
com.baeldung.reflection.innerclass.Person$Builder()

Surprisingly, in the constructor of the non-static Person$Address class, the compiler injects this$0 holding the reference to the enclosing Person class as the first argument. But the static class Person$Builder has no reference to the outer class in the constructor.

We’ll keep this behavior of the Java compiler in mind while instantiating the inner classes.

3. Instantiate a Static Inner Class

Instantiating a static inner class is almost similar to instantiating any normal class by using the method Class.forName(String className):

@Test
void givenStaticInnerClass_whenUseReflection_thenInstantiate()
    throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException,
      InstantiationException, IllegalAccessException {
    final String personBuilderClassName = "com.baeldung.reflection.innerclass.Person$Builder";
    Class<Person.Builder> personBuilderClass = (Class<Person.Builder>) Class.forName(personBuilderClassName);
    Person.Builder personBuilderObj = personBuilderClass.getDeclaredConstructor().newInstance();
    assertTrue(personBuilderObj instanceof Person.Builder);
}

We passed the fully qualified name “com.baeldung.reflection.innerclass.Person$Builder” of the inner class to Class.forName(). Then we called the newInstance() method on the constructor of the Person.Builder class to get personBuilderObj.

4. Instantiate a Non-Static Inner Class

As we saw before, the Java compiler injects the reference to the enclosing class as the first parameter to the constructor of the non-static inner class.

With this knowledge, let’s try instantiating the Person.Address class:

@Test
void givenNonStaticInnerClass_whenUseReflection_thenInstantiate()
    throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException,
      InstantiationException, IllegalAccessException {
    final String personClassName = "com.baeldung.reflection.innerclass.Person";
    final String personAddressClassName = "com.baeldung.reflection.innerclass.Person$Address";
    Class<Person> personClass = (Class<Person>) Class.forName(personClassName);
    Person personObj = personClass.getConstructor().newInstance();
    Class<Person.Address> personAddressClass = (Class<Person.Address>) Class.forName(personAddressClassName);
    assertThrows(NoSuchMethodException.class, () -> personAddressClass.getDeclaredConstructor(String.class));
    
    Constructor<Person.Address> constructorOfPersonAddress = personAddressClass.getDeclaredConstructor(Person.class, String.class);
    Person.Address personAddressObj = constructorOfPersonAddress.newInstance(personObj, "751003");
    assertTrue(personAddressObj instanceof Person.Address);
}

First, we created the Person object. Then, we passed the fully qualified name “com.baeldung.reflection.innerclass.Person$Address” of the inner class to Class.forName(). Next, we got the constructor Address(Person this$0, String zip) from personAddressClass.

Finally, we called the newInstance() method on the constructor with the personObj and zip 751003 parameters to get personAddressObj.

We also see that the method personAddressClass.getDeclaredConstructor(String.class) throws NoSuchMethodException because of the missing first argument this$0.

5. Conclusion

In this article, we discussed the Java Reflection API to instantiate static and non-static inner classes. We found that the compiler treats the inner classes as an external class instead of an embedded class in the outer class.

Also, the constructors of the non-static inner class by default take an outer class object as the first argument. However, we can instantiate the static classes similar to any normal class.

As usual, the code used can be found over on GitHub.