[me:]

Agreed.

I agree with that too, but that might not be what the OP wanted.

FWIW, I'll append my attempt at this.  Largely untested....

   -- chris

====== LeastCommonSuperclass.java =========
public class LeastCommonSuperclass
{
   // We implement the following rules:
   //   LCS of null and any type is null.
   //   LCS of interface and any class is the interface if the class
implements
   //         it, or Object otherwise.
   //   LCS of interface and any other interface is whichever interface
   //         extends (including indirectly) the other one, or Object if
   //         neither does.
   //   LCS of primitive type and any distinct type is null.
   //   LCS of array type and any distinct class is Object.

   public static Class<?>
   of(Class<?>... classes)
   {
       Class<?> retval = classes[0];    // exception if size == 0
       for (Class<?> cl : classes)
           retval = of(retval, cl);
       return retval;
   }

   public static Class<?>
   of(Class<?> class1, Class<?> class2)
   {
       if (class1 == class2)
           return class1;
       if (class1 == null || class2 == null)
           return null;
       if (!class1.isArray() && class1.isAssignableFrom(class2))
           return class1;
       if (!class2.isArray() && class2.isAssignableFrom(class1))
           return class2;
       if (class1.isInterface() || class2.isInterface())
           return Object.class;
       return of(class1.getSuperclass(), class2.getSuperclass());
   }
}
===========================================

Not true.  Robert's algorithm check all of this things:

    // check if a first argument is a superclass of a second one
    if (c1.isAssignableFrom (c2)) return c1;
    // check if a second argument is a superclass of a first one
    if (c2.isAssignableFrom (c1)) return c2;

piotr