关于Class.isInstance的困惑

Question

Is it possible in java to get the complete hierarchy of an object? I have checked the javadoc for the Class class and i cant find such a method. Also, what i find strange is the result for the following code:

public static void main(String[] args) throws ClassNotFoundException {
    ClassLoader loader = ClassLoaderTest.class.getClassLoader();
    Class<?> clazz = loader.loadClass("java.lang.Integer");
    System.out.println(clazz.getSuperclass()); //prints java.lang.Number
    System.out.println(clazz.isInstance(clazz.getSuperclass())); //returns false??

    Number number = new Integer(1);//no class cast exception
}

The doc for the isInstance() method says:

Determines if the specified {@code Object} is assignment-compatible * with the object represented by this {@code Class}.

So since we can assign Integer to Number, why does:

java.lang.Integer.class.isInstance(java.lang.Number.class);

return false?

Thx

Answer 1

To re-quote the javadoc

Determines if the specified Object is assignment-compatible * with the object represented by this Class .

In the expression

java.lang.Integer.class.isInstance(java.lang.Number.class);

you are checking if the object returned by the expression java.lang.Number.class is an instance of Integer . It is not, it is an instance of java.lang.Class .

It should be used like

java.lang.Integer.class.isInstance(new Integer(1)); // if you want it to return true

You can pass it anything you want, but it will only return true if the argument used is an Integer or one of its sub types (but it is final so there aren't any).

Integer is a sub type of Number .

Any Integer instance can be used where a Number object is required.

Answer 2

In order to obtain the "complete hierarchy", you can recursively walk from the starting class through all its superlcasses and their implemented interfaces

import java.util.LinkedHashSet;
import java.util.Set;

public class Superclasses
{
    public static void main(String[] args)
    {
        Class<?> c = Integer.class;

        System.out.println("Superclasses:");
        Set<Class<?>> superclasses = superclasses(c);
        for (Class<?> s : superclasses)
        {
            System.out.println(s);
        }
    }

    private static Set<Class<?>> superclasses(Class<?> c)
    {
        LinkedHashSet<Class<?>> set = new LinkedHashSet<Class<?>>();
        superclasses(c, set);
        return set;
    }

    private static void superclasses(Class<?> c, Set<Class<?>> set)
    {
        if (c == null)
        {
            return;
        }
        set.add(c);
        if (c.equals(Object.class))
        {
            return;
        }
        superclasses(c.getSuperclass(), set);
        for (Class<?> i : c.getInterfaces())
        {
            superclasses(i, set);
        }
    }

}

Note that the situation is slightly more complicated when you als want to obtain the generic superclasses. For example, when you have a class like List<Integer> and want to obtain all superclasses including Collection<? extends Number> Collection<? extends Number> and Iterable<? extends Serializable> Iterable<? extends Serializable> . I have implemented this, but it is a bit of a hassle, because the set of superclasses in this sense is infinite, and you have to stop somewhere...