Determine if a Class Implements an Interface in Java

1. Overview

In this tutorial, we’ll take a look at several ways to determine if an object or a class implements a specific interface.

2. Using Java Reflection API

The Java Reflection API provides several ways to check whether an object or a class implements an interface. Using this API prevents adding a third-party library to our project.

2.1. The Data Model

The Java Runtime Environment(JRE) provides some ways to retrieve the implemented interfaces of a class.

First, let’s define a model with some interfaces and classes. For this example, we’ll define an interface MasterInterface and two sub-interfaces that extend the first one:

We’ll do the same for the classes with a first one implementing the MasterInterface and two subclasses implementing interfaces ChildInterface1 and ChildInterface2, respectively:

Here’s the code for our model:

public interface MasterInterface {}

public interface ChildInterface1 extends MasterInterface {}

public interface ChildInterface2 extends MasterInterface {}

public class MasterClass implements MasterInterface {}

public class ChildClass1 implements ChildInterface1 {}

public class ChildClass2 implements ChildInterface2 {}

2.2. The getInterfaces() Method

The Java API provides a getInterfaces() on the Class object. This method retrieves the implemented interfaces of a Class. We can get all implemented interfaces of a class with this line of code:

List<Class<?>> interfaces = Arrays.asList(childClass2.getClass().getInterfaces());

assertEquals(1, interfaces.size());
assertTrue(interfaces.contains(ChildInterface2.class));

As we can see, this method only retrieves the directly implemented interfaces. Inheritance of the MasterInterface is not detected.

If we want to get a full inheritance tree, we’ll have to recurse over the implemented interfaces until we find the root interface:

static Set<Class<?>> getAllExtendedOrImplementedInterfacesRecursively(Class<?> clazz) {

    Set<Class<?>> res = new HashSet<Class<?>>();
    Class<?>[] interfaces = clazz.getInterfaces();

    if (interfaces.length > 0) {
        res.addAll(Arrays.asList(interfaces));

        for (Class<?> interfaze : interfaces) {
            res.addAll(getAllExtendedOrImplementedInterfacesRecursively(interfaze));
        }
    }

    return res;
}

Then, after execution, we can check that we retrieved the MasterInterface in the Set:

assertTrue(interfaces.contains(ChildInterface2.class));
assertTrue(interfaces.contains(MasterInterface.class));

And now, we’re able to check if our object implements a specific interface in our model.

2.3. isAssignableFrom() Method

The previous method is quite verbose and painful, so the Java API provides a quicker way to check if an Object implements an interface. We can check this with the isAssignableFrom() method of the Class Object.

This method returns a true if the object inherits the specified interface, even if this isn’t a direct implementation:

ChildClass2 childClass2 = new ChildClass2();
assertTrue(MasterInterface.class.isAssignableFrom(childClass2.getClass()));

2.4. isInstance() Method

The Class object also provides an isInstance() method. This method returns true if the provided object implements the interface:

assertTrue(MasterInterface.class.isInstance(childClass2));

2.5. instanceOf Operator

The last way to check if an object implements an interface is to use the instanceOf operator. This operator also works with interfaces:

assertTrue(childClass2 instanceof MasterInterface);

3. Using Apache Commons Library

The Apache Commons Lang library provides utility classes for almost everything. The ClassUtils class is able to list all implemented interfaces of a class.

First of all, we need to add the Maven Central dependency to our pom.xml:

<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-lang3</artifactId>
  <version>3.12.0</version>
</dependency>

This is basically the same as the way we saw with the getInterfaces() method but we’ll only need one line of code :

List<Class<?>> allSuperInterfaces = ClassUtils.getAllInterfaces(childClass2.getClass());

This returns all implemented interfaces recursively:

assertTrue(allSuperInterfaces.contains(ChildInterface2.class)); assertTrue(allSuperInterfaces.contains(MasterInterface.class));

4. Using Reflections Library

The Reflections library is a third-party library that scans our objects and then allows us to run queries against the metadata collected.

We first need to add the Maven Central dependency to our pom.xml:

<dependency>
  <groupId>org.reflections</groupId>
  <artifactId>reflections</artifactId>
  <version>0.10.2</version>
</dependency>

The library needs to collect data before we can run our queries, so it needs to be initialized:

Reflections reflections = new Reflections("com.baeldung.checkInterface");

This operation scans the entire classpath provided and can take some time to complete. This may be done during the startup of our application so that future queries run smoothly.

Then, we can retrieve a list of interfaces implemented by a class:

Set<Class<?>> classes = reflections.get(ReflectionUtils.Interfaces.of(ChildClass2.class));

5. Conclusion

In this article, we saw different ways to check if a class implements a specific interface. Depending on the needs of our application, we can use standard Java Reflections API or rely on third-party libraries if we need more powerful functions.