Why don't wrapper classes have a common supertype?

Question

Is there a particular reason behind java wrapper classes (java.lang.Integer, java.lang.Boolean, ...) not having a common supertype ?

---

I'm asking because it would be quite handy to have (e.g.) WrapperType::getType function along the classic Object::getClass which would return the class of the primitive type.

More specifically, the context is invoking constructors via reflection where you only have the Class<T> and the parameters Object[]

E.g:

public static <T> T createInstance(Class<T> clz, Object... params) throws Exception

In order to get the constructor I can get the parameter types via:

Class<?>[] c = Arrays
        .stream(params)
        .map(Object::getClass)
        .toArray(Class<?>[]::new);
return clz.getConstructor(c).newInstance(params);

but this will of course fail with constructors like String::new(char[], int, int);

If that supertype existed I could do:

.map( o -> o.getClass().isPrimitive() ? ((WrapperType) o).getType() : o.getClass() )

---

I guess there is a particular reason java developers did not implement it.

Answer 1

Java designers probably aren't too abstract in their decisions and couldn't find many similarities between numeric types (e.g. Integer) and non-numeric types (e.g. Boolean) to group them by a superclass.

Though, all the numeric types extend Number which truly represents "numeric values that are convertible to the primitive types byte, double, float, int,long, short".

Actually, all the wrapper classes have a common interface Comparable<T> (e.g. Comparable<Integer> for Integer).