code: public List<Class<?>> directSuperclasses(Class<?> c)
      {
          if(c.isPrimitive()) {
              return primitiveSuperclasses(c);
          }
          else if(c.isArray()) {
              return arrayDirectSuperclasses(0, c);
          }
          else {
              List<Class<?>> interfaces = Arrays.asList(c.getInterfaces());
              Class<?> superclass = c.getSuperclass();
  
              if(c == Object.class) {
                  return ImmutableList.of();
              } else if(superclass == null && interfaces.isEmpty()) {
                  return classList(Object.class);
              } else if(superclass == Object.class) {
                  return newArrayList(concat(interfaces, classList(Object.class)));
              } else if(superclass == null) {
                  return interfaces;
              } else {
                  System.out.println("default: " + newArrayList(concat(classList(superclass), interfaces)));
                  return newArrayList(concat(classList(superclass), interfaces));
              }
          }
      }
docs: Get the direct superclasses of a class.
  This is complicated, and possibly evil: in dylan, any class
  which does not have another direct superclass extends Object.
  In java, interfaces do not extend Object, or any equivalent.
  This implementation makes an interface with no super interfaces
  extend Object. Further, in classes which extend object, and
  implement 1 or more interfaces, Object is last in the list
  of direct superclasses, while any other super class comes first.
  This seems a bit arbitrary, but works, and gives sensible
  results in most cases.