Détermination des interfaces étendues d'une classe

Question

je besoin pour déterminer si un objet de classe représentant une interface étend une autre interface, à savoir:

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

selon the spec Class.getSuperClass() retourne nulle pour une interface.

Si cette classe représente soit la classe Object, une interface, un type primitif, ou nulle, alors nul est retourné.

Par conséquent, les éléments suivants ne fonctionneront pas.

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 
} 

des idées?

Answer 1

Utilisez Class.getInterfaces tels que:

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

également le code suivant pourrait être utile, il vous donnera un ensemble avec tous les super-classes et interfaces d'une certaine classe:

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

Edit: Ajout de code pour obtenir toutes les super-classes et interfaces d'une certaine classe.

Answer 2

Jetez un coup d'œil à Class.getInterfaces();

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

Answer 3

Est-ce que Class.isAssignableFrom() fait ce dont vous avez besoin?

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

est ce que vous voulez

que je reçois toujours la commande en arrière au début, mais a récemment réalisé que c'est exactement le contraire d'utiliser instanceof

if (extendedInterfaceA instanceof interfaceB) 

est la même chose, mais vous avoir des instances des classes plutôt que les classes elles-mêmes

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