Reflection API in Java

Reflection is the ability of a Java program to examine and use classes at run time, including classes it knew nothing about when it was compiled. With reflection, a program can ask an object "which class are you?", list that class's fields, methods and constructors, read annotations, create objects, and call methods, all by name. The API lives in java.lang.Class and the package java.lang.reflect. Frameworks depend on it: Spring creates your beans, JUnit finds your test methods, and Jackson turns objects into JSON, all through reflection. In this lesson, you will learn about the Class object, how to get one, what it can tell you, and what reflection costs.

The Class Object

For every class, interface, enum, record, array type and primitive type that is loaded, the JVM creates one object of type java.lang.Class that describes it. This object is the entry point to everything else in reflection.

Three Ways to Get a Class Object

Class.forName takes the fully qualified name and throws the checked ClassNotFoundException if no such class can be found.

Methods of Class

Example: Asking a Class About Itself

import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
 
public class Meet {
    interface Printable { }
    static class Person { }
 
    static final class Student extends Person
            implements Printable, Comparable<Student> {
        public int compareTo(Student o) {
            return 0;
        }
    }
 
    record Point(int x, int y) { }
    enum Color { RED }
 
    public static void main(String[] args) throws Exception {
        Class<Student> a = Student.class;
        Class<?> b = new Student().getClass();
        Class<?> c = Class.forName("Meet$Student");
        System.out.println(a == b && b == c);
 
        System.out.println(a.getName());
        System.out.println(a.getSimpleName());
        System.out.println(a.getSuperclass().getSimpleName());
        System.out.println(Arrays.toString(a.getInterfaces()));
        System.out.println(Modifier.toString(a.getModifiers()));
        System.out.println(Point.class.isRecord() + " "
            + Color.class.isEnum() + " " + Printable.class.isInterface()
            + " " + int[].class.isArray());
        System.out.println(int.class.getName() + " "
            + int[].class.getName() + " " + String[].class.getName()
            + " " + int[].class.getSimpleName());
        System.out.println(new ArrayList<String>().getClass()
            == new ArrayList<Integer>().getClass());
        System.out.println(ArrayList.class.getModule().getName());
        try {
            Class.forName("com.school.Missing");
        } catch (ClassNotFoundException e) {
            System.out.println("ClassNotFoundException: " + e.getMessage());
        }
    }
}

true
Meet$Student
Student
Person
[interface Meet$Printable, interface java.lang.Comparable]
static final
true true true true
int [I [Ljava.lang.String; int[]
true
java.base
ClassNotFoundException: com.school.Missing

Explanation:

• true: all three ways return the same Class object. There is exactly one per loaded class (per class loader).
• Meet$Student: the JVM's name for a nested class joins the outer and inner names with $. That is the name Class.forName needs.
• Interfaces: Comparable appears without <Student>. Generic type arguments are erased from the class itself.
• Array names: the JVM writes int[] as [I and String[] as [Ljava.lang.String;. getSimpleName() gives the readable form.
• ArrayList<String> vs ArrayList<Integer>: both objects have the same class, which is type erasure seen through reflection.

What Reflection Is Used For

The Costs of Reflection

Common Mistakes

Passing a simple name to Class.forName. It needs the full name with the package, and $ for nested classes.

Using reflection where an interface would do. If you control the classes, give them a common interface and call it normally.

Looking up the same Method or Field again and again. Look it up once and keep it.

Interview Corner

Practice

1. Easy: Print the name, superclass and interfaces of java.util.ArrayList and java.lang.Integer.
2. Harder: Write a method that takes any object and prints its whole superclass chain up to Object, using getSuperclass() in a loop.

Key Takeaways