public ClassComparator() 
{
    
        super();
}

Defaultconstructor.

 public int compare(Object o1,
    Object o2) 
{
        final Class c1 = (Class) o1;
        final Class c2 = (Class) o2;
        if (c1.equals(o2)) {
            return 0;
        }
        if (c1.isAssignableFrom(c2)) {
            return -1;
        }
        else {
            if (!c2.isAssignableFrom(c2)) {
                throw new IllegalArgumentException(
                    "The classes share no relation"
                );
            }
            return 1;
        }
}

Compares its two arguments for order. Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.

Note: throws ClassCastException if the arguments' types prevent them from being compared by this Comparator. And IllegalArgumentException if the classes share no relation. The implementor must ensure that sgn(compare(x, y)) == -sgn(compare(y, x)) for all x and y. (This implies that compare(x, y) must throw an exception if and only if compare(y, x) throws an exception.)

The implementor must also ensure that the relation is transitive: ((compare(x, y)>0) && (compare(y, z)>0)) implies compare(x, z)>0.

Finally, the implementer must ensure that compare(x, y)==0 implies that sgn(compare(x, z))==sgn(compare(y, z)) for all z.

It is generally the case, but not strictly required that (compare(x, y)==0) == (x.equals(y)). Generally speaking, any comparator that violates this condition should clearly indicate this fact. The recommended language is "Note: this comparator imposes orderings that are inconsistent with equals."

 public boolean isComparable(Class c1,
    Class c2) 
{
        return (c1.isAssignableFrom(c2) || c2.isAssignableFrom(c1));
}

Checks, whether the given classes are comparable. This method will return true, if one of the classes is assignable from the other class.