Check if a Class Object is subclass of another Class Object in Java

Question

I'm playing around with Java's reflection API and trying to handle some fields. Now I'm stuck with identifying the type of my fields. Strings are easy, just do myField.getType().equals(String.class). The same applies for other non-derived classes. But how do I check derived classes? E.g. LinkedList as subclass of List. I can't find any isSubclassOf(...) or extends(...) method. Do I need to walk through all getSuperClass() and find my supeclass by my own?

LinkedList isn't a subclass of List. It's an implementation of List. — T.J. Crowder
– T.J. Crowder, Commented Jan 3, 2011 at 12:51

Joachim Sauer · Accepted Answer · 2020-03-23 08:00:04Z

497

You want this method:

boolean isList = List.class.isAssignableFrom(myClass);

where in general, List (above) should be replaced with superclass and myClass should be replaced with subclass

From the JavaDoc:

Determines if the class or interface represented by this Class object is either the same as, or is a superclass or superinterface of, the class or interface represented by the specified Class parameter. It returns true if so; otherwise it returns false. If this Class object represents a primitive type, this method returns true if the specified Class parameter is exactly this Class object; otherwise it returns false.

Reference:

Class.isAssignableFrom(Class)

Related:

a) Check if an Object is an instance of a Class or Interface (including subclasses) you know at compile time:

boolean isInstance = someObject instanceof SomeTypeOrInterface;

Example:

assertTrue(Arrays.asList("a", "b", "c") instanceof List<?>);

b) Check if an Object is an instance of a Class or Interface (including subclasses) you only know at runtime:

Class<?> typeOrInterface = // acquire class somehow
boolean isInstance = typeOrInterface.isInstance(someObject);

Example:

public boolean checkForType(Object candidate, Class<?> type){
    return type.isInstance(candidate);
}

edited Mar 23, 2020 at 8:00

Joachim Sauer

309k59 gold badges568 silver badges624 bronze badges

answered Jan 3, 2011 at 12:49

Sean Patrick Floyd

301k72 gold badges481 silver badges598 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

codepleb Over a year ago

Note the scheme: SUPERCLASS.isAssignableFrom(SUBCLASS) This confused me first, altough it is actually obvious considering the naming.

Sean Patrick Floyd Over a year ago

@TrudleR I agree. Something like SUPERCLASS.isExtendedBy(SUBCLASS) would be much easier to understand

Qw3ry Over a year ago

@SeanPatrickFloyd actually isExtendedBy is a bad name as CLASS.isAssignableFrom(CLASS) would be true (and therefore CLASS.isExtendedBy(CLASS) as well). This would not be what I expected.

Sean Patrick Floyd Over a year ago

@Qw3ry yes, I'm assuming that's also what the Api authors thought :-)

Landei · Accepted Answer · 2011-01-03 12:59:08Z

31

Another option is instanceof:

Object o =...
if (o instanceof Number) {
  double d = ((Number)o).doubleValue(); //this cast is safe
}

answered Jan 3, 2011 at 12:59

Landei

54.6k13 gold badges105 silver badges195 bronze badges

4 Comments

Sean Patrick Floyd Over a year ago

Good call (+1). And then there is also the combination of the two mechanisms: Class.isInstance(object) download.oracle.com/javase/6/docs/api/java/lang/…

craesh Over a year ago

This would imply, that you instanciate that Field. But I just want to "look" at my class and its fields, don't want to "try them out".

cbuchart Over a year ago

I see this method much cleaner and clearer than the "isAssignableFrom" way, in the case you need to check the inheritance tree of an object.

lukaszrys Over a year ago

Keep in mind that instanceof also works for parent (in this case Number) itself not only childrens

Marco · Accepted Answer · 2013-11-08 08:44:57Z

instanceof works on instances, i.e. on Objects. Sometimes you want to work directly with classes. In this case you can use the asSubClass method of the Class class. Some examples:

1)

    Class o=Object.class;
    Class c=Class.forName("javax.swing.JFrame").asSubclass(o);

this will go through smoothly because JFrame is subclass of Object. c will contain a Class object representing the JFrame class.

2)

    Class o=JButton.class;
    Class c=Class.forName("javax.swing.JFrame").asSubclass(o);

this will launch a java.lang.ClassCastException because JFrame is NOT subclass of JButton. c will not be initialized.

3)

    Class o=Serializable.class;
    Class c=Class.forName("javax.swing.JFrame").asSubclass(o);

this will go through smoothly because JFrame implements the java.io.Serializable interface. c will contain a Class object representing the JFrame class.

Of course the needed imports have to be included.

To Kra · Accepted Answer · 2015-07-24 16:39:26Z

6

This works for me:

protected boolean isTypeOf(String myClass, Class<?> superClass) {
    boolean isSubclassOf = false;
    try {
        Class<?> clazz = Class.forName(myClass);
        if (!clazz.equals(superClass)) {
            clazz = clazz.getSuperclass();
            isSubclassOf = isTypeOf(clazz.getName(), superClass);
        } else {
            isSubclassOf = true;
        }

    } catch(ClassNotFoundException e) {
        /* Ignore */
    }
    return isSubclassOf;
}

answered Jul 24, 2015 at 16:39

To Kra

3,6173 gold badges43 silver badges46 bronze badges

1 Comment

Jonas Pedersen Over a year ago

Works nice, but you might have to add a null check after clazz = clazz.getSuperclass() in case you hit java.lang.Object who does not have a super class.

user2415587 · Accepted Answer · 2018-01-31 19:36:39Z

This is an improved version of @schuttek's answer. It is improved because it correctly return false for primitives (e.g. isSubclassOf(int.class, Object.class) => false) and also correctly handles interfaces (e.g. isSubclassOf(HashMap.class, Map.class) => true).

static public boolean isSubclassOf(final Class<?> clazz, final Class<?> possibleSuperClass)
{
    if (clazz == null || possibleSuperClass == null)
    {
        return false;
    }
    else if (clazz.equals(possibleSuperClass))
    {
        return true;
    }
    else
    {
        final boolean isSubclass = isSubclassOf(clazz.getSuperclass(), possibleSuperClass);

        if (!isSubclass && clazz.getInterfaces() != null)
        {
            for (final Class<?> inter : clazz.getInterfaces())
            {
                if (isSubclassOf(inter, possibleSuperClass))
                {
                    return true;
                }
            }
        }

        return isSubclass;
    }
}

Georg Plaz · Accepted Answer · 2019-02-12 13:21:12Z

4

A recursive method to check if a Class<?> is a sub class of another Class<?>...

Improved version of @To Kra's answer:

protected boolean isSubclassOf(Class<?> clazz, Class<?> superClass) {
    if (superClass.equals(Object.class)) {
        // Every class is an Object.
        return true;
    }
    if (clazz.equals(superClass)) {
        return true;
    } else {
        clazz = clazz.getSuperclass();
        // every class is Object, but superClass is below Object
        if (clazz.equals(Object.class)) {
            // we've reached the top of the hierarchy, but superClass couldn't be found.
            return false;
        }
        // try the next level up the hierarchy.
        return isSubclassOf(clazz, superClass);
    }
}

edited Feb 12, 2019 at 13:21

Georg Plaz

6,0185 gold badges44 silver badges66 bronze badges

answered Apr 20, 2017 at 19:37

schuttek

1561 silver badge10 bronze badges

Comments

joseluisbz · Accepted Answer · 2019-04-26 02:38:19Z

//Inheritance

    class A {
      int i = 10;
      public String getVal() {
        return "I'm 'A'";
      }
    }

    class B extends A {
      int j = 20;
      public String getVal() {
        return "I'm 'B'";
      }
    }

    class C extends B {
        int k = 30;
        public String getVal() {
          return "I'm 'C'";
        }
    }

//Methods

    public static boolean isInheritedClass(Object parent, Object child) {
      if (parent == null || child == null) {
        return false;
      } else {
        return isInheritedClass(parent.getClass(), child.getClass());
      }
    }

    public static boolean isInheritedClass(Class<?> parent, Class<?> child) {
      if (parent == null || child == null) {
        return false;
      } else {
        if (parent.isAssignableFrom(child)) {
          // is child or same class
          return parent.isAssignableFrom(child.getSuperclass());
        } else {
          return false;
        }
      }
    }

// Test the code

    System.out.println("isInheritedClass(new A(), new B()):" + isInheritedClass(new A(), new B()));
    System.out.println("isInheritedClass(new A(), new C()):" + isInheritedClass(new A(), new C()));
    System.out.println("isInheritedClass(new A(), new A()):" + isInheritedClass(new A(), new A()));
    System.out.println("isInheritedClass(new B(), new A()):" + isInheritedClass(new B(), new A()));


    System.out.println("isInheritedClass(A.class, B.class):" + isInheritedClass(A.class, B.class));
    System.out.println("isInheritedClass(A.class, C.class):" + isInheritedClass(A.class, C.class));
    System.out.println("isInheritedClass(A.class, A.class):" + isInheritedClass(A.class, A.class));
    System.out.println("isInheritedClass(B.class, A.class):" + isInheritedClass(B.class, A.class));

//Result

    isInheritedClass(new A(), new B()):true
    isInheritedClass(new A(), new C()):true
    isInheritedClass(new A(), new A()):false
    isInheritedClass(new B(), new A()):false
    isInheritedClass(A.class, B.class):true
    isInheritedClass(A.class, C.class):true
    isInheritedClass(A.class, A.class):false
    isInheritedClass(B.class, A.class):false

jwpol · Accepted Answer · 2020-10-30 12:39:25Z

2

In addition to @To-kra's answer. If someone doesn't like recurrence:

    public static boolean isSubClassOf(Class<?> clazz, Class<?> superClass) {
        if(Object.class.equals(superClass)) {
            return true;
        }

        for(; !Object.class.equals(clazz); clazz = clazz.getSuperclass()) {
            if(clazz.getSuperclass().equals(superClass)) {
                return true;
            }
        }

        return false;
    }

NOTE: no null checking for clarity.

answered Oct 30, 2020 at 12:39

jwpol

1,5251 gold badge15 silver badges30 bronze badges

Collectives™ on Stack Overflow

Check if a Class Object is subclass of another Class Object in Java

8 Answers 8

4 Comments

4 Comments

Comments

1 Comment

Comments

Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

8 Answers 8

4 Comments

4 Comments

Comments

1 Comment

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related