Controllare se un oggetto classe è una sottoclasse di un altro oggetto classe in Java

Sto giocando con l'API di riflessione di Java e sto cercando di gestire alcuni campi. Ora sono bloccato con l'identificazione del tipo dei miei campi. Le stringhe sono facili, basta myField.getType().equals(String.class). Lo stesso vale per altre classi non derivate. Ma come posso controllare le classi derivate? Ad esempio LinkedListcome sottoclasse di List. Non riesco a trovare alcuna isSubclassOf(...)o di extends(...)metodo. Devo percorrere tutto getSuperClass()e trovare la mia supeclass per conto mio?

Vuoi questo metodo:

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

dove in generale, List(sopra) dovrebbe essere sostituito con superclasse myClassdovrebbe essere sostituito consubclass

Da JavaDoc :

Determina se la classe o l'interfaccia rappresentata da questo Classoggetto è uguale o è una superclasse o superinterfaccia della classe o dell'interfaccia rappresentata dal Classparametro specificato . Ritorna in truetal caso; altrimenti ritorna false. Se questo Classoggetto rappresenta un tipo primitivo, questo metodo restituisce truese il Classparametro specificato è esattamente questo Classoggetto; altrimenti ritorna false.

Riferimento:

• Class.isAssignableFrom(Class)

Relazionato:

a) Verifica se un oggetto è un'istanza di una classe o interfaccia (comprese le sottoclassi) che conosci al momento della compilazione:

boolean isInstance = someObject instanceof SomeTypeOrInterface;

Esempio:

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

b) Verifica se un oggetto è un'istanza di una classe o interfaccia (comprese le sottoclassi) che conosci solo in fase di esecuzione:

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

Esempio:

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

Un'altra opzione è instanceof:

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

instanceof funziona su istanze, cioè su Oggetti. A volte vuoi lavorare direttamente con le lezioni. In questo caso è possibile utilizzare il metodo asSubClass della classe Class. Qualche esempio:

1)

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

questo andrà a buon fine perché JFrame è una sottoclasse di Object. c conterrà un oggetto Class che rappresenta la classe JFrame.

2)

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

questo avvierà un java.lang.ClassCastException perché JFrame NON è una sottoclasse di JButton. c non verrà inizializzato.

3)

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

questo andrà a buon fine perché JFrame implementa l'interfaccia java.io.Serializable. c conterrà un oggetto Class che rappresenta la classe JFrame.

Naturalmente le importazioni necessarie devono essere incluse.

Questo funziona per 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;
}

Questa è una versione migliorata della risposta di @ schuttek. È stato migliorato perché restituisce correttamente false per primitive (ad es. IsSubclassOf (int.class, Object.class) => false) e gestisce correttamente anche le interfacce (ad es. 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;
    }
}

Un metodo ricorsivo per verificare se a Class<?>è una sottoclasse di un'altra Class<?>...

Versione migliorata di @ su Kra 's risposta :

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);
    }
}

//Eredità

    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'";
        }
    }

// Metodi

    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;
        }
      }
    }

// Prova il codice

    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));

//Risultato

    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