Determinación de las interfaces extendidos de un Clase

Question

necesito para determinar si un objeto de clase que representa una interfaz extiende otra interfaz, es decir:

package a.b.c.d; 
    public Interface IMyInterface extends a.b.d.c.ISomeOtherInterface{ 
    } 

según the spec Class.getSuperClass() devolverá nulo para una interfaz.

Si esta clase representa o bien la clase objeto, una interfaz, un tipo primitivo , o nula, entonces nula es devueltos.

Por lo tanto, lo siguiente no funcionará.

Class interface = Class.ForName("a.b.c.d.IMyInterface") 
Class extendedInterface = interface.getSuperClass(); 
if(extendedInterface.getName().equals("a.b.d.c.ISomeOtherInterface")){ 
    //do whatever here 
} 

¿Alguna idea?

Answer 1

Use Class.getInterfaces tales como:

Class<?> c; // Your class 
for(Class<?> i : c.getInterfaces()) { 
    // test if i is your interface 
} 

también el siguiente código podría ser de ayuda, se le dará un conjunto con todas las superclases e interfaces de una determinada clase:

public static Set<Class<?>> getInheritance(Class<?> in) 
{ 
    LinkedHashSet<Class<?>> result = new LinkedHashSet<Class<?>>(); 

    result.add(in); 
    getInheritance(in, result); 

    return result; 
} 

/** 
* Get inheritance of type. 
* 
* @param in 
* @param result 
*/ 
private static void getInheritance(Class<?> in, Set<Class<?>> result) 
{ 
    Class<?> superclass = getSuperclass(in); 

    if(superclass != null) 
    { 
     result.add(superclass); 
     getInheritance(superclass, result); 
    } 

    getInterfaceInheritance(in, result); 
} 

/** 
* Get interfaces that the type inherits from. 
* 
* @param in 
* @param result 
*/ 
private static void getInterfaceInheritance(Class<?> in, Set<Class<?>> result) 
{ 
    for(Class<?> c : in.getInterfaces()) 
    { 
     result.add(c); 

     getInterfaceInheritance(c, result); 
    } 
} 

/** 
* Get superclass of class. 
* 
* @param in 
* @return 
*/ 
private static Class<?> getSuperclass(Class<?> in) 
{ 
    if(in == null) 
    { 
     return null; 
    } 

    if(in.isArray() && in != Object[].class) 
    { 
     Class<?> type = in.getComponentType(); 

     while(type.isArray()) 
     { 
      type = type.getComponentType(); 
     } 

     return type; 
    } 

    return in.getSuperclass(); 
} 

Editar: Se agregó un código para obtener todas las superclases e interfaces de una cierta clase.

Answer 2

Eche un vistazo a Class.getInterfaces();

List<Object> list = new ArrayList<Object>(); 
for (Class c : list.getClass().getInterfaces()) { 
    System.out.println(c.getName()); 
} 

Answer 3

Does Class.isAssignableFrom() hacer lo que necesita?

Class baseInterface = Class.forName("a.b.c.d.IMyInterface"); 
Class extendedInterface = Class.forName("a.b.d.c.ISomeOtherInterface"); 

if (baseInterface.isAssignableFrom(extendedInterface)) 
{ 
    // do stuff 
} 

Answer 4

if (interface.isAssignableFrom(extendedInterface)) 

es lo que quiere

siempre me dan la orden al revés en un primer momento, pero recientemente se dio cuenta de que es exactamente lo contrario de utilizar instanceof

if (extendedInterfaceA instanceof interfaceB) 

es lo mismo, pero se tiene que tener instancias de las clases en lugar de las clases en sí

Answer 5

Liast<Class> getAllInterfaces(Class<?> clazz){ 
    List<Class> interfaces = new ArrayList<>(); 
    Collections.addAll(interfaces,clazz.getInterfaces()); 
    if(!clazz.getSuperclass().equals(Object.class)){ 
     interfaces.addAll(getAllInterfaces(clazz.getSuperclass())); 
    } 
    return interfaces ; 
}