poliformismo - static poo java




Verifique se um objeto de classe é uma subclasse de outro objeto de classe em Java (4)

Estou brincando com a API de reflexão do Java e tentando lidar com alguns campos. Agora estou preso a identificar o tipo dos meus campos. As strings são fáceis, basta fazer myField.getType().equals(String.class) . O mesmo se aplica a outras classes não derivadas. Mas como faço para verificar classes derivadas? Por exemplo, LinkedList como subclasse de List . Não consigo encontrar nenhum isSubclassOf(...) ou extends(...) . Preciso percorrer todo o getSuperClass() e encontrar meu supeclass por conta própria?


Esta é uma versão melhorada da resposta do @ schuttek. Ele é melhorado porque retorna corretamente false para primitivos (por exemplo, isSubclassOf (int.class, Object.class) => false) e também manipula corretamente as interfaces (por exemplo, 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;
    }
}

Isso funciona para mim:

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

Um método recursivo para verificar se uma Class<?> É uma subclasse de outra Class<?> ...

Versão melhorada da answer de :

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

Você quer este método:

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

onde, em geral, List (acima) deve ser substituído por superclass e myClass deve ser substituído por subclass

Do JavaDoc :

Determina se a classe ou interface representada por este objeto Class é igual ou é uma superclasse ou superinterface da classe ou interface representada pelo parâmetro Class especificado. Ele retorna true se assim for; caso contrário, retorna false . Se este objeto Class representar um tipo primitivo, esse método retornará true se o parâmetro Class especificado for exatamente esse objeto Class ; caso contrário, retorna false .

Referência:

Relacionado:

a) Verifique se um objeto é uma instância de uma classe ou interface (incluindo subclasses) que você conhece em tempo de compilação:

boolean isInstance = someObject instanceof SomeTypeOrInterface;

Exemplo:

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

b) Verifique se um objeto é uma instância de uma classe ou interface (incluindo subclasses) que você só conhece em tempo de execução:

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

Exemplo:

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






reflection