Java Distance Calculate distanceToInterface(Class<?> theClass, Class<?> theInterface)

Description

Compute the hierarchical distance between the given class and the given interface.

License

LGPL

Parameter

Parameter	Description
theClass	the class to check.
theInterface	the interface.

Return

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.

Declaration

public static int distanceToInterface(Class<?> theClass, Class<?> theInterface)

Method Source Code

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

Java Distance Calculate distanceToInterface(Class theClass, Class theInterface)