Invoke a Static Method Using Java Reflection API

Last updated: August 7, 2025

Written by: Kai Yuan

Reviewed by: Eric Martin

Core Java

Reflection

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

1. Overview

In this quick tutorial, we’ll discuss how to invoke a static method in Java by using the Reflection API.

We’ll cover two different scenarios:

The static method is public.
The static method is private.

2. An Example Class

To make the demonstration and explanation easier, let’s first create a GreetingAndBye class as the example:

public class GreetingAndBye {

    public static String greeting(String name) {
        return String.format("Hey %s, nice to meet you!", name);
    }

    private static String goodBye(String name) {
        return String.format("Bye %s, see you next time.", name);
    }
}

The GreetingAndBye class looks pretty simple. It has two static methods, one public and one private.

Both methods accept a String argument and return a String as the result.

Now, let’s call the two static methods using the Java Reflection API. In this tutorial, we’ll address the code as unit test methods.

3. Invoking a public static Method

First, let’s see how to call the public static method:

@Test
void invokePublicMethod() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    Class<GreetingAndBye> clazz = GreetingAndBye.class;
    Method method = clazz.getMethod("greeting", String.class);

    Object result = method.invoke(null, "Eric");

    Assertions.assertEquals("Hey Eric, nice to meet you!", result);
}

We should note that we need to handle the required checked exceptions when we use the Reflection API.

In the example above, we first obtain the instance of the class we want to test, which is GreetingAndBye.

After we have the class instance, we can get the public static method object by calling the getMethod method.

Once we hold the method object, we can invoke it simply by calling the invoke method.

It’s worthwhile to explain the first argument of the invoke method. If the method is an instance method, the first argument is the object from which the underlying method is invoked.

However, when we invoke a static method, we pass null as the first argument, as static methods don’t require an instance in order to be called.

Finally, if we run the test, it’ll pass.

3. Invoking a private static Method

Invoking a private static method is pretty similar to invoking a public one. Let’s take a look at the code first:

@Test
void invokePrivateMethod() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    Class<GreetingAndBye> clazz = GreetingAndBye.class;
    Method method = clazz.getDeclaredMethod("goodBye", String.class);
    method.setAccessible(true);

    Object result = method.invoke(null, "Eric");

    Assertions.assertEquals("Bye Eric, see you next time.", result);
}

As we can see in the code above, when we try to get the Method object of a private method, we should use getDeclaredMethod instead of getMethod.

Moreover, we need to call method.setAccessible(true) to invoke a private method. This will ask the JVM to suppress the access control checks on this method.

Thus, it allows us to invoke the private method. Otherwise, an IllegalAccessException exception will be raised.

The test will pass if we execute it.