Checking if a Java Class Is ‘Abstract’ Using Reflection

Last updated: January 8, 2024

Written by: baeldung

Reviewed by: Kevin Gilmore

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 we can check if a class is abstract or not in Java by using the Reflection API.

2. Example Class and Interface

To demonstrate this, we’ll create an AbstractExample class and an InterfaceExample interface:

public abstract class AbstractExample {

    public abstract LocalDate getLocalDate();

    public abstract LocalTime getLocalTime();
}

public interface InterfaceExample {
}

3. The Modifier#isAbstract Method

We can check if a class is abstract or not by using the Modifier#isAbstract method from the Reflection API:

@Test
void givenAbstractClass_whenCheckModifierIsAbstract_thenTrue() throws Exception {
    Class<AbstractExample> clazz = AbstractExample.class;
 
    Assertions.assertTrue(Modifier.isAbstract(clazz.getModifiers()));
}

In the example above, we first obtain the instance of the class we want to test. Once we have the class reference, we can call the Modifier#isAbstract method. As we’d expect, it returns true if the class is abstract, and otherwise, it returns false.

It’s worthwhile to mention that an interface class is abstract as well. We can verify it by a test method:

@Test
void givenInterface_whenCheckModifierIsAbstract_thenTrue() {
    Class<InterfaceExample> clazz = InterfaceExample.class;
 
    Assertions.assertTrue(Modifier.isAbstract(clazz.getModifiers()));
}

If we execute the test method above, it’ll pass.

The Reflection API provides an isInterface() method as well. If we want to check if a given class is abstract but not an interface, we can combine the two methods:

@Test
void givenAbstractClass_whenCheckIsAbstractClass_thenTrue() {
    Class<AbstractExample> clazz = AbstractExample.class;
    int mod = clazz.getModifiers();
 
    Assertions.assertTrue(Modifier.isAbstract(mod) && !Modifier.isInterface(mod));
}

Let’s also validate that a concrete class returns the appropriate results:

@Test
void givenConcreteClass_whenCheckIsAbstractClass_thenFalse() {
    Class<Date> clazz = Date.class;
    int mod = clazz.getModifiers();
 
    Assertions.assertFalse(Modifier.isAbstract(mod) && !Modifier.isInterface(mod));
}