Force subclasses to use type parameter

Question

When I create a class with a type parameter:

public abstract class AbstractBox<T> {
    abstract T getContent();
}

then I can still create a subclass without a type parameter:

class SomeBox extends AbstractBox {             // DISALLOW THIS
    @Override
    Something getContent() {
        return null;
    }
}

Can I somehow force subclasses to provide a type parameter (even if it's just Object)? For instance, I want to disallow the above but allow:

class SomeBox extends AbstractBox<Something> {  // ALLOW THIS
    @Override
    Something getContent() {
        return null;
    }
}

EDIT: This is not a duplicate of Can overridden methods differ in return type?. That question asks if overriding methods can return subtypes of the type parameter.

My question asks if I can enforce that any subclass of an abstract with a type parameter must provide a type parameter.

Answer 1

If you want to check if AbstractBox is provided with a type parameter when extended you can do this:

abstract class AbstractBox<T> {
    protected AbstractBox() {
        // First, find the direct subclass of AbstractBox
        Class<?> cls = getClass();
        while(cls.getSuperclass() != AbstractBox.class)
            cls = cls.getSuperclass();

        // Then, check if it's superclass is parametrized
        if (!(cls.getGenericSuperclass() instanceof ParameterizedType)) {
            throw new RuntimeException("Must parametrize the extension of AbstractBox.");
        }
    }

    abstract T getContent();
}

Getting the direct subclass first is needed so that it doesn't break in the case where a direct subclass extends AbstractBox with a parameter, and is then subclassed again.

Note that this will also accept the case of SomBox extends AbstractBox<String>.