Here you can find the source of distanceToInterface(Class> theClass, Class> theInterface)
Parameter | Description |
---|---|
theClass | the class to check. |
theInterface | the interface. |
0
if the two parameters are equals, to 1
if the class directly implements the interface and is incremented by 1
for each ancestor between the class and the interface.
public static int distanceToInterface(Class<?> theClass, Class<?> theInterface)
//package com.java2s; //License from project: LGPL public class Main { /**//from ww w. j ava 2 s . c om * Compute the hierarchical distance between the given class and the given interface. * The hierarchical distance is equals to <code>0</code> if the two parameters are equals, * to <code>1</code> if the class directly implements the interface * and is incremented by <code>1</code> for each ancestor between the class and the interface.<br> * If the given class do not implements the given interface, the result is <code>-1</code>. * @param theClass the class to check. * @param theInterface the interface. * @return <code>0</code> if the two parameters are equals, * to <code>1</code> if the class directly implements the interface * and is incremented by <code>1</code> for each ancestor between the class and the interface. * @see #isImplements(Class, Class) */ public static int distanceToInterface(Class<?> theClass, Class<?> theInterface) { int tmpDistance = 0; Class<?>[] interfaces = null; if ((theClass != null) && (theInterface != null) && (theInterface.isInterface())) { // If the given class and the interface are the same. if (theInterface.equals(theClass)) { return 0; } else { // Search if the interface is directly declared on the class itself. In this case, // the method return true. If the interface is not declared within the given class, // its interface hierarchy is recursively processed. interfaces = theClass.getInterfaces(); if ((interfaces != null) && (interfaces.length > 0)) { for (int j = 0; j < interfaces.length; j++) { // The given interface is declared directly by the class if (theInterface.equals(interfaces[j])) { return 1; } } // The interface was not found within the class hierarchy, we now look at the implementation hierarchy. for (int j = 0; j < interfaces.length; j++) { tmpDistance = distanceToInterface(interfaces[j], theInterface); if (tmpDistance > -1) { return 1 + tmpDistance; } } interfaces = null; } // the interface was not found within the class declared interface, // the search is done following the class hierarchy tmpDistance = distanceToInterface(theClass.getSuperclass(), theInterface); if (tmpDistance > -1) { return 1 + tmpDistance; } } } return -1; } }