Creating Non-Object Specific Methods

Question

Is it possible to make a method that uses an object as a parameter, but doesn't specify exactly what type of object will be passed? The method would try to use the compareTo method that most objects have.

Also, is it possible to check if an object has a compareTo method, and throw an exception if it doesn't?

Answer 1

The only thing you need your objects to do is to implement the Comparable interface. Java will ensure that anything you're passing in would be type-safe at compile time, meaning you don't have to throw any kind of runtime exception.

From there, you may leverage any of the standard sort methods from Java:

• Collections#sort
• Arrays.sort

(Note that with Arrays.sort, it expects an Object[], but will throw an exception if the contract of Comparable is violated.)

Answer 2

From your description, it sounds to me like what you're asking for is to use casting:

/**
 * @param  lhs
 * @param  rhs
 * @return the result of comparing lhs to rhs via compareTo
 * @throws NullPointerException
 *         if lhs or rhs is null
 * @throws ClassCastException
 *         if lhs or rhs does not implement Comparable or
 *         if lhs and rhs are not mutually comparable
 * @see    Comparable#compareTo(Object)
 */
@SuppressWarnings({"rawtypes", "unchecked"})
private static int compareByCasting(Object lhs, Object rhs) {
    Comparable compL = (Comparable) lhs;
    Comparable compR = (Comparable) rhs;
    return compL.compareTo(compR);
}

This is how methods like Arrays.sort work behind the scenes.

That said, it's very rarely necessary to write code like that, unless you're writing very low-level API like in the case of Arrays.sort. Java has static typing, so in general the goal is to program towards pushing type checks to compile-time so we don't have to run the program to verify that it's correct. That's why we use tools like interfaces and generics.

Answer 3

a generic custom method with a constraint like below should enable you to compare objects that implement the generic Comparable interface, therefore, removing the need to take a parameter of type Object and then ensuring it has a compareTo method somehow.

public <T extends Comparable<T>> int comparer(T thiss, T that){
       // do logic
}

Answer 4

sorting method [...] an array of objects

If all of these objects are the same type and implement comparable, you can use generics

Note that if they are not similarly typed, you'll need to write a custom method to compare
(ie Integer and String comparison)

private <A extends Comparable<A>> void bigger(A a, A b)
{
    if(a.compareTo(b) > 0)
        System.out.println("a bigger");
    else
        System.out.println("b bigger");
}

Do note that this will only work for same typed objects

//works
String a = "5";
String b = "6";
bigger(a, b);

//compile error
Integer c = 5;
String d = "6";
bigger(c, d);

This works for things that implement Comparable

On custom objects, it's normally straightforward to implement

class Duck implements Comparable<Duck>
{
    private int height;
    [...]
    public int compareTo(Duck other)
    {
        return height - other.height;
    }
}

The cool thing about this, is most of the sorting bits of the Java API are built to handle Comparable

---

If you do not know that they are Comparables and stuck keeping everything as Objects, then you are most likely stuck using Reflection

int compare(Object a, Object b) throws NoSuchMethodException, IllegalAccessException, java.lang.reflect.InvocationTargetException
{
    return (Integer)a.getClass().getMethod("compareTo", b.getClass()).invoke(a, b);
}