java: Class.isInstance vs Class.isAssignableFrom

Dejen clazzser algunos Classy objsean algunos Object.

Es

clazz.isAssignableFrom(obj.getClass())

siempre lo mismo que

clazz.isInstance(obj)

?

Si no es así, ¿cuáles son las diferencias?

clazz.isAssignableFrom(Foo.class)será verdadero siempre que la clase representada por el clazzobjeto sea una superclase o superinterfaz de Foo.

clazz.isInstance(obj)será verdadero siempre que el objeto objsea ​​una instancia de la clase clazz.

Es decir:

clazz.isAssignableFrom(obj.getClass()) == clazz.isInstance(obj)

siempre es cierto siempre clazzy cuando no objsean nulos.

Ambas respuestas están en el estadio pero ninguna es una respuesta completa.

MyClass.class.isInstance(obj)es para verificar una instancia. Devuelve verdadero cuando el parámetro obj no es nulo y se puede convertir MyClasssin generar a ClassCastException. En otras palabras, obj es una instancia de MyClasso sus subclases.

MyClass.class.isAssignableFrom(Other.class)devolverá true si MyClasses el mismo que, o una superclase o superinterfaz de, Other. Otherpuede ser una clase o una interfaz. Responde verdadero si Otherse puede convertir a a MyClass.

Un pequeño código para demostrar:

public class NewMain
{
    public static void main(String[] args)
    {
        NewMain nm = new NewMain();
        nm.doit();
    }

    class A { }

    class B extends A { }

    public void doit()
    {
        A myA = new A();
        B myB = new B();
        A[] aArr = new A[0];
        B[] bArr = new B[0];

        System.out.println("b instanceof a: " + (myB instanceof A)); // true
        System.out.println("b isInstance a: " + A.class.isInstance(myB)); //true
        System.out.println("a isInstance b: " + B.class.isInstance(myA)); //false
        System.out.println("b isAssignableFrom a: " + A.class.isAssignableFrom(B.class)); //true
        System.out.println("a isAssignableFrom b: " + B.class.isAssignableFrom(A.class)); //false
        System.out.println("bArr isInstance A: " + A.class.isInstance(bArr)); //false
        System.out.println("bArr isInstance aArr: " + aArr.getClass().isInstance(bArr)); //true
        System.out.println("bArr isAssignableFrom aArr: " + aArr.getClass().isAssignableFrom(bArr.getClass())); //true
    }
}

Creo que el resultado para esos dos debería ser siempre el mismo. La diferencia es que necesita una instancia de la clase para usar isInstancepero solo el Classobjeto para usar isAssignableFrom.

Por brevedad, podemos entender estas dos API como a continuación:

1. X.class.isAssignableFrom(Y.class)

Si Xy Yson la misma clase, o Xes Yla superclase o la super interfaz, devuelve verdadero, de lo contrario, falso.

2. X.class.isInstance(y)

Say yes una instancia de clase Y, si Xy Yson la misma clase, o Xes Yla superclase o la super interfaz, devuelve verdadero, de lo contrario, falso.